Category: Programação Web

05_IntroducaoASP.NET MVC

Introdução ao MVC:
separação do UI de uma aplicação em três aspectos:
Controller (partilha eventos com a view e faz ligação ao model)
Model (partilha propriedades com a view)
View
(vista, modelo e controlador)
vista (nterface do utilizador para apresentação dos dados, isto é, representa o UI da aplicação)
modelo
controlador (Traduz as ações do utilizador em operações apropriadas; e é o cérebro da operação, responsável por tratar o pedido HTTP)

exemplo dos procedimentos:
endereço web, controlador, modelo e depois a view

existe um Router que selecciona o controlador correcto para tratar do request

os Actions Selectores são atributos que podem ser aplicados aos Actions Methods, e permitem o mecanismo de routing identificar o action correcto para manipular determinado pedido.

//exemplo do HttpGet 
//no controlador
[HttpGet]
public ActionResult Edit(int id)
{
}
//na view
@Html.ActionLink("Editar", "Edit", new { id = item.Id })

As actions podem ter parâmetros de entrada (tipos de dados primitivos ou complexos)
e para isso é necessário que o controlador receba esses valores

public ActionResult Editar(int id)
{
return Content("id=" + id);
}
Tags :

06_ASP.NET Passagem Dados, ViewsRazorLayouts

A passagem de dados:
A passagem de dados do Controlador à Vista, e ao próximo request, pode ser efetuada de outras formas para além da passagem de dados através de um argumento da View

Pode ser usado nas passagem de dados:
ViewData emque o Objeto é do tipo dicionário, acessível usando strings como chaves e necessita do type casting para tipos complexos
ou o ViewBag, objecto do tipo dinâmico, não necessita de type casting nem verificações de null e as propriedades são adicionadas em tempo de execução

//exemplo: ViewData
//no controlador
public ActionResult Vencedor()
{
var pescador = new Pescador() { Nome = "Pedro" };
ViewData["PescadorData"] = pescador;
return View();
}
//na View
@using MVC1.Models
@model MVC1.Models.Pescador
@{
ViewBag.Title = "Vencedor";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h2>@(((Pescador)ViewData["PescadorData"]).Nome)</h2>

ou

//exemplo: ViewBag
//no controlador
public ActionResult Vencedor()
{
var pescador = new Pescador() { Nome = "Pedro" };
ViewBag.PescadorProp = pescador;
return View();
}
//na View
@using MVC1.Models
@model MVC1.Models.Pescador
@{
ViewBag.Title = "Vencedor";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h2>@ViewBag.PescadorProp.Nome</h2>

As viewes:
A view não deve executar qualquer lógica de negócio, ou interagir com a base de dados directamente.
Deve trabalhar somente com os dados que lhe são fornecidos pelo controlador.

//exemplo para obter /pescadores/Index
public ActionResult Index()
{
return View();
}
//exemplo para obter /pescadores/OutraView
public ActionResult Index()
{
return View("OutraView");
}

A Sintaxe Razor:
Minimiza a quantidade de sintaxe e caracteres extra
Codifica automaticamente qualquer output enviado através do @ de forma a prevenir ataques cross site scripting
Blocos de código estão delimitados com @{ … }
Ficheiros C# tem extensão .cshtml

//exemplo razor view
@{ var mensagem = "Programação"; }
<p>O valor da Mensagem é: @mensagem</p>
@{
var boasVindas= "Bem vindo ao Razor!";
var diaSemana= DateTime.Now.DayOfWeek;
var mensagem = boasVindas + " Hoje é " + diaSemana;
}

Os Layouts:
_Layout.cshtml, Define o que se quer apresentar em todas as páginas da aplicação
A view _Layout deve ser especificada na pasta Shared existente na secção Views
E o RenderBody permite especificar onde será apresentado o conteúdo individual das views

Tags : , , ,

07_Forms, HtmlHelpers, Validações – DataAnnotations

Os Html Helpers permitem:
Permitem a geração de elementos HTML

O Razor view engine já define um conjunto de helpers
Permite criar de forma simples pequenos blocos html tais como:
Criação de elementos de inputs;
Criação de ligações;
Criação de forms;

Existem três tipos de Html Helpers:
HTML Helpers Inline
Built-in HTML Helpers
e HTML Helpers personalizados

@Html.ActionLink(“Novo Aluno”, “Create”)
significa que:
Novo Aluno

Podemos fazer uso do @HTML.TextBox() usando o:
Método loosely typed e não apresenta erros de compilação quando se especifica o nome da propriedade errado,

ou
Método strongly typed que apresenta erro de compilação quando se especifica um nome de propriedade errado e gera o elemento TextBox para a propriedade especificada no modelo, recorrendo a uma expressão lambda

//exemplo:
@Html.TextBox("Nome", null, new { @class = "form-control" })
@Html.TextBoxFor(m => m.Nome, new { @class = "form-control" })

o uso do For permite verificar erros em tempo de compilação

//outros exemplos:
@Html.LabelFor(model => model.Numero, htmlAttributes: new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.Numero, new { htmlAttributes = new { @class = "form-control" } })
@Html.HiddenFor(model => model.Id)
@Html.DisplayNameFor(model => model.Numero)
@Html.DisplayFor(model => model.Numero)

As DataAnnotations é uma forma de adicionar informação contextual a classes ou membros da classe;

Existem três categorias principais:
Validation
Display
Modelling

//exemplo:
[StringLength(50,MinimumLength = 3)]
//exemplo:
[Required(ErrorMessage = "Especifique um nome.")]
//exemplo:
[StringLength(50,MinimumLength = 3,ErrorMessage ="O nome deve ter no mínimo 3 e maximo de 50 carateres.")]
//exemplo:
[Range(0, 18, ErrorMessage ="Idade deve estar entre 0 e 18")]
//exemplo:
[Display(Name = "Endereço Eletrónico")]
//exemplo:
[DisplayFormat(ApplyFormatInEditMode =true,DataFormatString ="{0:c}")]
//exemplo:
[ReadOnly(true)]
//exemplo:
[RegularExpression(@"\d{9}", ErrorMessage = "Nº de Telemovel invalido!")]
//exemplo:
[StringLength(10, MinimumLength = 5)]

e pelo uso das ValidationMessageFor surgem:

<div class="form-group">
@Html.LabelFor(model => model.Morada, htmlAttributes: new { @class = "control-label col-md-2" })
<div class="col-md-10">
@Html.EditorFor(model => model.Morada, new { htmlAttributes = new { @class = "form-control" } })
@Html.ValidationMessageFor(model => model.Morada, "", new { @class = "text-danger" })
</div>
</div>

A validação do lado do cliente pode ser feita recorrendo a expressões do jQuery
A validação dos dados:
o MVC executa a lógica de validação durante o model binding, através dos métodos métodos UpdateModel e TryUpdateModel de um controlador

//exemplo: Model Binding
public ActionResult Edit(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Aluno aluno = db.Alunos.Find(id);
if (aluno == null)
{
return HttpNotFound();
}
return View(aluno);
}
Tags : , ,

09_EntityFramework_CodeFirst

Os passos para trabalhar com o modo de 09_EntityFramework são:
_criar o contexto (classe que herda da DBcontext)
_especificar a connection string no ficheiro web.config

De seguida devemos:
criar os diferentes modelos de dados por exemplo:
aluno..

public class Aluno
{
public int AlunoID { get; set; }
public string AlunoNome { get; set; }
public DateTime? DataNascimento { get; set; }
public IList<Disciplina> Disciplinas { get; set; }
public Aluno()
{
}
}

Disciplina..

public class Disciplina
{
public int DisciplinaId { get; set; }
public string DisciplinaNome { get; set; }
public Curso Curso { get; set; }
public Docente Docente { get; set; }
public IList<Aluno> Alunos { get; set; }
}

Curso..

public enum Curso
{
INFORMATICA=1,
BIOMEDICA=2,
CIVIL=3,
MECANICA=4
}

Docente..

{
public class Docente
{
public int DocenteId { get; set; }
public string DocenteNome { get; set; }
}

Depois existe a necessidade de criar o contexto

public class EscolaContext : DbContext
{
public EscolaContext() : base("name=DefaultConnection")
{
}
public DbSet<Aluno> Alunos { get; set; }
public DbSet<Disciplina> Disciplinas { get; set; }
public DbSet<Docente> Docentes{ get; set; }
}

Especificar a conenection string no ficheiro web.config
Ir aos nugetpackage manager, e package manager manager console
Activar as Migrations: comando enable-migrations
Criar uma migration: comando add-migration “modeloInicialV0” (sempre que alterarmos os modelos)
E actualizar a base de dados: update-database

No ficheiro configuration.cs podemos realizar o seed das entidades e acrescentar dummy data nas tabelas
exemplo do seed (e a dummy data está noutro CS):

context.FixedStations.AddOrUpdate(
	f => new { f.RecordDateFs, f.LocalizationFs, f.StartIndexDisponibilityFs, f.EndIndexDisponibilityFs }, 
	DummyData.GetFixedStations().ToArray()
);
context.SaveChanges();

exemplo de dummy data:

context.Docentes.AddOrUpdate(a => a.DocenteNome, new Docente
{
DocenteNome = "Maria",
Disciplinas = new Collection<Disciplina>() {
new Disciplina() {DisciplinaNome="POO" }
}
});
}

É possivel alterar o que as convenções geram através de um processo de overriden:
usando DataAnnotaions ou FluentAPI

As DataAnnotaions:
simples de especificar, menos flexíveis, úteis para anotações simples: obrigações, tamanhos, máximos..

//exemplo de DataAnnotations
[Table("Alunos")]
public class Aluno
{}
//ou
[MaxLength(150), Required]
//ou
public DateTime? DataNascimento { get; set; }
//ou
[Column("Nome",TypeName="varchar")]
//ou
[ForeignKey("Docente")]
public int DocenteId { get; set; }
public virtual Docente Docente { get; set; }
//ou
[Key]
//ou
[NotMapped]

o FluentAPI:
permite configurar a configuração de relacionamentos entre classes mais complexas, separações de concerns
As fluentApi são escritas nos contextos
O código deve ser aplicado no método OnModelCreating(DbModelBuilder modelBuilder) da class que deriva do DbContext
Permite mais controlo na definição das relações usando HAS e o With

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// Aplica as configurações recorrendo ao Fluent API
}
//exemplo de FluentAPI
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Disciplina>()
.Property(t => t.DisciplinaNome)
.IsRequired();
//ou
modelBuilder.Entity<Aluno>().ToTable("Alunos");
//ou
modelBuilder.Entity<Aluno>().HasKey(t => t.NAluno);

Podemos usar ambas mas temos que ter em conta que as precedências são:
FluentAPI
DataAnnotaions
Convenções

Os relacionamentos com o fluentApi:
HasMany() – Se A tem muitos objetos to B
HasRequired – Se A tem apenas um objeto de B
HasOptional – Se A tem 0 ou 1 objeto de B
WithMany() – Se B tem muitos objetos to A
WithRequired – Se B tem apenas um objeto de A
WithOptional – Se B tem 0 ou 1 objeto de A

//relacionamento 1-N
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithRequired(d => d.Professor)
.HasForeignKey(d => d.ProfessorId);
//relacionamento N-M
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithMany(d => d.Professores)
.Map(m => m.ToTable("ProfessorDisciplinas“)) 
//relacionamento 1-0..1
modelBuilder.Entity<Professor>()
.HasOptional(p => p.Disciplina)
.WithRequired(d => d.Professor);
//relacionamento 1-1
modelBuilder.Entity<Professor>()
.HasRequired(p => p.Disciplina)
.WithRequiredPrincipal(d => d.Professor);
Tags :

08_EntityFramework e DatabaseFirst

O objectivo da EntityFramework é o de aumentar a produtividade do programador, reduzindo tarefas redundantes para persistência de dados

Existem várias forma de especificar o modelo de dados:
Database First (Bd -> classes de domínio)
CodeFirst (classes de dominio -> Bd)
ModelFirst (UML e surgem as classes de dominio via EF e a base de dados)

O contexto (Model.Contex.cs):
Contem a classe que deriva da classe DbContext
Fornece a propriedade para cada classe do modelo que corresponde a tabela da BD (Fornecedor.cs Cliente.cs)

Os modelos:
os modelos representam as tabelas da base de dados
quando pretendemos usar o “maldito” scaffolding, recorremos à classe de contexto e ao modelo de classes

o Linq e a EntityFramework:
o Lazy Loading: o loading não é executado de forma imediata, é apenas quando se acede aos elementos (bom apenas para aplicações desktop)

Problema do n+1 do lazy loading:
fazer uso de inlcude

Alternativa ao lazy loading, é o explicit loading:
útil quando se pretende efectuar o load de muitos objectos e as queries ficam complexas (as queries são separadas), mas faz muitas queries na base de dados
ou o Eager loading:
quando se obtém os dados da BD em apenas um round-trip e faz uso de joins

Como adicionar objectos na BD:

//v1
var aluno = new Aluno { Nome = "Pedro",
UserName="pedro@residual.ptt",
Email ="pedro@residual.pt",
CursoId=1
};
db.Alunos.Add(aluno);
db.SaveChanges();

ou

//v2
var cursos = db.Cursos.ToList();
var curso = db.Cursos.Single(c => c.CursoId == 1);
var aluno = new Aluno { Nome = "Pedro",
UserName="pedro@residual.pt",
Email ="pedro@residual.pt",
Curso = curso
};
db.Alunos.Add(aluno);
db.SaveChanges();

Como alterar objectos na BD:

var curso = db.Cursos.Find(4); // ou var curso = db.Cursos.Single(c => c.CursoId == 4);
curso.Objectivos = "Curso bla bla bla";
curso.Nome = "Novo Nome";
db.SaveChanges();

Como remover objectos na BD:

//Com CascadeDelete ativo
var curso = db.Cursos.Find(4);
db.Cursos.Remove(curso);
db.SaveChanges();

Ou

//Sem CascadeDelete ativo
var curso = db.Cursos.Include(c => c.Alunos)
.Single(c => c.CursoId == 4);
db.Alunos.RemoveRange(curso.Alunos);
db.Cursos.Remove(curso);
db.SaveChanges();
Tags : ,

10_Security in web applications (pweb)

Segurança em aplicações Web
O que é uma vulnerabilidade? é uma fraqueza que permite aos atacantes ganharem acesso ao sistema ou a informações
Causas de vulnerabilidades:
complexidade
falhas no desenho da app
software bugs
falhas ao nível das passwords e privilégios

Uma vulnerabilidade é uma fault, que deixa espaço para a exploração maliciosa de um sistema.

Exemplo de ameaças ao software:
Denial of service (Oversize Payload, Coercive Parsing, Oversize Cryptography, Attack Obfuscation, Unvalidated Redirects and Forwards)
Brute force (Insecure Cryptographic Storage, Broken Authentication and Session Management)
Spoofing (Insufficient Transport Layer Protection, Metadata Spoofing, Security misconfiguration)
Injection (SQL Injection, Cross site Scripting (XSS), Cross Site Request Forgery, XPath Injection)
Flooding (Instantiation Flood, Indirect Flooding, BPEL State Deviation)

Exemplo de vulnerabilidades de aplicações web:
_estão expostas
_os hackers movem as suas atenções da rede para o código da aplicação web
_aplicação de vários níveis de ataques: (portas da network, tempered values, o código implementado nas aplicações)

Vulnerabilidades (injection vulnerabilities):
SQL injection (alterar a expressão de SQL que está a ser usada, alterar os dados da base de dados ou até mesmo executar comandos no sistema)
XPath injection (modificar o xpath que está previamente programado, ou ganhar acesso através do acesso a documentos XML)
Code execution (é possivel manipular os dados de entrada para enganar o ocidgo do servidor)
Cross-site request forgery (CSRF) (o utilizador pode manipular um utilizador para que este execute acções indesejadas assim que está autenticado. Faz isto enviado um link para o utilizador)

Soluções para segurança das aplicações web:
defense in depth: endurecendo todas as camadas da infraestrutura tecnológica através:
colocar restrições na capacidade do servidor de correr componentes autonomamente;
colocar ou elevar o nível dos filtros relacionados com os níveis de tráfico;
fazer uso de um IDS para identificar actividade anómala na infraestrutura;

Todas as entradas são consideradas maliciosas até prova em contrário.

Linhas de protecção:
Input validation (normalização dos dados de entrada, usar filtros para recusar valores fora do dominio)
Hotspot protection (garantir que está correctamente implementada)
Output validation (validar a saida de um determinado processo antes de este ser enviado)
Protect back-end resources (funcionalidades desnecessárias devem ser removidas, dedicar especial atenção quando se lida com informação)

Lidar com o SQL Injection:
impor validação do SQL;

Fazer uso de ferramentas online:
HP WebInspect
WSFuzzer
Acunetix
WatchFire
Rational APPScan
Foundstone
WEDigger

Tags : ,

04_Introdução ao C# (pweb)

POO, princípios básicos:
abstração
herança
encapsulamento
polimorfismo

O mundo tem objectos que possuem características e comportamentos. Todos os objectos têm: estado (conjunto de propriedades de um objecto), comportamento (conjunto de acções sobre o objecto), unicidade (todo o objecto é único).

Objecto = Dados + Código
Dados -> comunica com -> atributos
Código -> comunica com -> métodos

nivel_acesso class nome_da_classe
{
        // bloco de instruções
}

um classe tem:
nivel_acesso: nível de proteção da classe ( internal/public ou abstract ou sealed)
pode existir uma class @override -> permite substituir qualquer coisa (por exemplo um método)
pode existir numa class o virtual -> permite sobrescrever qualquer coisa  (por exemplo um método)
e o new é usado para ocultar um determinado método

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            @override x = new @override();
            Console.WriteLine(x.Numero);
            Console.ReadKey();
        }
    }
    class @override
    {
        public int Numero { get; set; }
        public @override()
        {
            Numero = 5;
        }
    }
}

o this serve para nos referirmos ao próprio (variável, campo, método..) do objecto e não a algo “local”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao("USA");

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        public string ONome="TAP";

        public Aviao()
        {
        }

        public Aviao(string nome)
        {
            this.ONome = nome;

        }
    }
}

assim uma classe tem os seguintes membros:
variáveis (campos ou atributos(members fields));
métodos
propriedades (gets e sets)

Os atributos têm sempre um nível de protecção:
private (por defeito),
public (acedido a partir de outras classes ou métodos),
protected (acedido a partir da classe onde foi declarado e/ou classes derivadas),

protected internal (acedido a partir de uma classe onde foi declarado ou de classes derivadas)

Podemos também dividir as classes, usando a terminologia partial

As classes também têm um nível de protecção:
internal (por defeito, a classe acedida apenas no projeto),
public (acedida de qualquer parte),
abstract ou internal abstract (acedida apenas no projeto e não pode ser instanciada, apenas derivada de)
public abstract (acessível de qualquer parte e não pode ser instanciada, apenas derivada de)
sealed (acessível apenas no projeto, não pode ser derivada, apenas instanciada)
public sealed
O encapsulamento tem como objectivo principal ocultar de pormenores internos da classe. Para fora vão apenas os métodos (se for o caso). Normalmente essa implementação é feita usando getters e setters

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do encapsulamento
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao();

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        private string nome = "TAP";
        public string ONome
        {
            get { return nome; }
            set { nome = value; }
        }
    }
}

Os métodos (funções dentro das classes) podem ter parâmetros, sendo que estes podem ser passados por valor, ou então por referência, ou uso do out.
O uso da referência (ref) permite actualizar uma variável.
Existe tambem o formato de out

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do ref
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int numero = -3;
           Console.WriteLine("mostra resultados {0}", a.FazContas(ref numero));

            Console.ReadKey();
        }
    }
    class Contas
    {
        private int valor = 10;

        public int FazContas (ref int recebe)
        {
            if (recebe &lt; 0)
            {
                valor = this.valor;
            }
            else
            {
                valor = recebe * recebe;
            }
            return valor;
        }
    }
}

Podemos também utilizar arrays, nomeadamente parâmetros como argumentos

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {

        //exemplo do arrays
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int[] numeros = {1,2,3};

            Console.WriteLine("mostra resultados {0}", a.FazContas(numeros));

            Console.ReadKey();
        }
    }
    class Contas
    {
        public int FazContas (params int[] recebeArray)
        {
            int soma = 0;
            foreach (var r in recebeArray)
            {
                soma += r;
            }
            return soma;
        }
    }
}

É possivel passar “invocar” um função ou método dependendo dos valores dos argumentos que recebe

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do argumentos
        static void Main(string[] args)
        {
            Argumentos();
            Argumentos(texto:"Peter");
            Console.ReadKey();
        }
        static void Argumentos(int numero = 0, string texto = "Portugal")
        {
            Console.WriteLine("mostra resultados {0}, {1}", numero, texto);
        }
    }
}

O polimorfismo:
definição de métodos ou interfaces, que são genéricos e que podem ser implementados de diversas formas
Vantagens do polimorfismo:
reutilizar código;
tempo de desenvolvimento;
manutenção.
A herança:
permite reutilizar o código, permite a construção de classes baseadas noutras, sendo que a subclasse:
herda todas as propriedades e métodos da classe base;
pode incluir ou sobrepor novas propriedades e métodos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo de herança
        static void Main(string[] args)
        {
            Filho f = new Filho();
            Console.WriteLine("mostrar {0}", f.Metodo2());
            Console.WriteLine("mostrar {0}", f.Metodo1());
            Console.ReadKey();
        }
        class Mae
        {
            private int numero = 10;
            public Mae() { }

            public int Metodo1()
            {
                return numero;
            }
        }

        class Filho:Mae
        {
            private int valor = 1;
            public int Metodo2()
            {
                return valor;
            }
        }
    }
}

Os membros da classe base, podem ser virtuais. A classe que herda uma classe com membros virtuais pode ser overridden pela classe que a herda, fazendo com que a classe derivada possa fornecer uma implementação alternativa para o membro.
O uso da palavra sealed evita que uma classe ou membros virtuais sejam herdados

uma classe base pode ser abstracta. É uma classe conceptual no qual se definem funcionalidades para as subclasses (que a herdam) e que possam implementá-las de forma não obrigatória.
se for estabelecido um método abstracto, então essa classe também o é. esse método não possui implementação na classe abstracta, apenas é e obrigatoriamente a sua definição e a implementação de ser feita na classe derivada.

Podem existir interfaces, usando a expressão interface
Todas as interfaces são publicas, os seus métodos não têm implementação, mas quem faz uso de uma interface tem que implementar as funcionalidades dos métodos.

Podem também tratar das excepções usando as expressões:
try
catch
finally
throw

Tags : ,

03_Introdução ao C# (pweb)

Acerca do C#:
arquitectura que faz uso de namespaces (uma classe que contem elementos, e que estes podem ser partilhados com outras classes)
recomendável instalar o ReSharper (https://www.jetbrains.com/)
todos os ficheiros têm extensão de .cs,
c# é case sensitive,
o compilador ignora os espaços vazios,
cada statement de C# termina com ponto e virgula,

using System; //namespace
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace csharp1
{
    class Program
    {
        static void Main(string[] args) //existe apenas um
        {
            string nome;
            Console.WriteLine("Olá Mundo!");
            Console.WriteLine("Qual o seu nome?");
            nome = Console.ReadLine();
            Console.WriteLine("Bem vindo {0}", nome);
            Console.ReadKey();
        }
    }
}

estrutura básica de um programa em c#:
tem vários namespace, como é o caso do using System;
contém um unico método chamado de main;
e no exemplo em cima:
vai escrever o Olá Mundo!
o método que faz esta acção é o WriteLine
Este método pertence ao objeto System.Console
Static, porque indica que o método Main pode ser chamado mesmo que não haja instância da classe

Nas variáveis podem ser usados literais: inteiros (L, long), reais (f, float)..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {
        static void Main(string[] args)
        {
            int numero = 24;
            string texto = "Pedro deste lado";

            Console.WriteLine($"{texto} {numero}");
            Console.ReadKey();
        }
    }
}

Enumerações (enums) permitem declarar uma lista de constantes

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {
        enum DiaFutebol : int
        {
            sextafeira = 0,
            sabado = 1,
            domingo = 2
        };
        static void Main(string[] args)
        {
            DiaFutebol DiaF = DiaFutebol.sextafeira;
            Console.WriteLine($"Dia de futebol {0}", DiaF);
            Console.ReadKey();
        }
    }
}

As estruturas:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

struct Aviao
{
    private string cor;
    public Aviao(string cor)
    {
        this.cor = cor;
    }
    public string Cor
    {
        get { return cor; }
        set { cor = "verde"; }
    }
    public string Descricao()
    {
        return "Cor de um avião = " + cor;
    }
}
namespace chsarp_v0
{
    class Program
    {   
        static void Main(string[] args)
        {
            Aviao aviao;
            aviao = new Aviao("Preto");
            Console.WriteLine(aviao.Descricao());
            Console.ReadKey();
        }
    }
}

Os arrays:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {   
        static void Main(string[] args)
        {
            int[] numeros = {1, 2, 3, 4, 5, 6, 7, 8, 9};
            Console.WriteLine("\\-primeira versão:");
            for (int i = 0; i < numeros.Length; i++)
            {
                Console.WriteLine("informacao {0}", numeros[i]);
            }
            Console.WriteLine("\\-segunda versão:");
            foreach (var anda in numeros) 
            {
                Console.WriteLine("informacao {0}", anda);
            }
            Console.ReadKey();
        }
    }
}
Tags : ,

02_Introdução (pweb)

A arquitectura típica:

Tecnologias e frameworks:

O ASP.NET:
é uma framework da microsoft para o desenvolvimento de aplicações web e web services;
possibilidade de utilizar várias linguagens: C#, VB.NET, C++;
code-behind: separação do código HTML;
arquitectura de controlos do lado do servidor;
uso do padrão Model-View-Controller (MVC);
a usar o ASP.NET MVC 5.. embora já exista a evolução com o Core 2.0;

Com o ASP.NET surgem vários modelos para a criação de aplicações web:
web forms (é uma transição do desenvolvimento de aplicações de desktop windows para aplicações web),
ASP.NET MVC (em que o MVC é um padrão de arquitectura de desenvolvimento que separa a aplicação em três componentes: Model (manipula regras de negócio, lógica de entradas), Controller (interação com o utilizador e lógica de entrada) e a View (apresentação). Nesta metodologia o Controller é uma classe separada, o que permite a automatização de testes, e os Controllers não estão limitados a uma view especifica. Esta arquitectura apresenta também como vantagens o desempenho e a escalabilidade.


ASP.NET Web pages, semelhante ao PHP, faz uso de modelos de single pages, e do razor view engine (criação dinâmica de páginas)

ASP.NET Web API, framework que permite desenvolver serviços HTTP

ASP.NET SignalIR, permite desenvolver aplicações em tempo real (exemplo: jogos)

 

Tags : ,