Seu próximo nível começa aqui
Com a Assinatura Ilimitada, você tem tudo que precisa para sua aprovação.
Com a Assinatura Ilimitada, você combina prática, teoria e método em uma única assinatura com tudo que você precisa para sua aprovação.
- Gran Questões
- Questões
Questões de Concurso sobre C#
Disciplina
1
Assunto
1
Banca
Instituição
Cargo
Ano
Carreira
Área de formação
Escolaridade
Dificuldade
Comentários:
Professores
Alunos
Meus Comentários
Vídeo
Minhas questões:
Resolvidas
Não resolvidas
Certas
Erradas
Tipo de questão:
Certo e errado
Múltipla escolha
Incluir questões:
Anuladas
Desatualizadas
Questões:
Todas as questões
Filtro simplificado
Questões
Todas as questões
193
questões
encontradas
20
Mais recentes
Considere o código fonte abaixo, que utiliza a sintaxe de marcação Razor para incorporar código baseado em C# em uma página da web.
@{
var resultado = "";
if (..I..)
{
var n1 = Request["t1"];
var n2 = Request["t2"];
var total = n1.AsInt() + n2.AsInt();
resultado = "Resultado = " + total;
}
}
<!DOCTYPE html>
<html>
<head><title>Exemplo</
<body>
<form action="" method="post">
<p>
<label for="text1">Primeiro valor:</
<input type="text" name="t1" id="text1">
</
<p>
<label for="text2">Segundo valor:</
<input type="text" name="t2" id="text1">
</
<p>
<input type="submit" value=" Soma">
</
</
<p> ..II.. </
</
</
Um Auditor precisa usar um comando na lacuna I para verificar se os dados do formulário foram submetidos usando o método post, e um comando na lacuna II para exibir o conteúdo da variável resultado. Os comandos que o Auditor deverá utilizar são, respectivamente,
A
isset($_POST) e echo resultado
B
IsPost e @resultado
C
@POST e ${resultado}
D
doPost() e out.print(resultado)
E
isPost() e ${resultado}
No C#, membros privados (private) de classes podem ser acessados
A
por qualquer classe no mesmo namespace.
B
somente pela classe em que foram declarados.
C
por classes abstratas.
D
apenas por classes derivadas.
E
por classes ascendentes.
Analise o código C# exibido a seguir.
Assinale o item com o resultado da execução desse código.
A
caso 1: 15
caso 2: 5
B
caso 3: 10
caso 1: 15
caso 2: 5
C
caso 3: 20
caso 1: 15
caso 2: 5
D
caso 3: 20
caso 1: 25
caso 2: 8
E
caso 3: 20
caso 1: 10
caso 2: 3
Considere o programa escrito abaixo em linguagem C:
Assinale a alternativa correta sobre o resultado impresso.
A
Uma mensagem de erro.
B
O valor O.
C
O valor 2.
D
O valor 20.
E
O valor 40.
Em relação ao mecanismo de passagem de parâmetros em C#, é correto afirmar:
A
Quando você passa um argumento para um método, o parâmetro correspondente é inicializado com uma cópia do argumento, inclusive para um tipo-referência.
B
As palavras-chaves ref e out indicam, respectivamente, passagem de parâmetro por referência e por valor.
C
Parâmetros declarados com o modificador virtual indicam que as superclasses precisam definir seu tipo.
D
O modificador override atribuído a um argumento de método, implica o ocultamento do tipo definido na classe-pai.
E
Argumentos do tipo int que recebam parâmetros do tipo WrappedInt sofrem a operação de boxing antes da cópia dos valores.
Um Auditor está trabalhando junto com uma equipe de desenvolvimento de uma aplicação em C#, que necessita de uma estrutura capaz de armazenar diversos objetos de um tipo de classe específico, de tal forma que seja facilitada a adição, consulta e remoção de elementos. Para tal, a equipe optou pelo uso da lista abaixo.
List<Pessoa> lista = new List<Pessoa>();
Pessoa p1 = new PessoaJuridica();
Pessoa p2 = new PessoaFisica();
Pessoa p3 = new PessoaJuridica();
lista.Add(p1);
lista.Add(p2);
lista.Add(p3);
Para percorrer os elementos desta lista obtendo cada objeto do tipo Pessoa, utiliza-se o comando
A
foreach (Pessoa p in lista) { }
B
for(int indice=0; indice<=lista.Length(); indice++){lista.Get(Pessoa p);}
C
while(Pessoa p from lista) { }
D
for(int i=1; i<=lista.Length(); i++) {List.GetAt(Pessoa p);}
E
foreach(Get Pessoa in lista) { }
Em um programa construído na linguagem C# da plataforma Microsoft .NET, um Auditor se deparou com uma condição if(x && y), em que x e y são valores booleanos (bool). Na instrução if,
A
caso x seja false, y não será avaliado.
B
tanto x quanto y serão sempre avaliados.
C
caso y seja true, x não será avaliado.
D
somente x será avaliado.
E
somente y será avaliado.
Observe o programa C# a seguir.
using System;
public class Program{
static void Func(ref int a, out int b){
b = a;
}
public static void Main() {
int x;
Func(ref x, out x);
Console.WriteLine(x);
}
}
Esse código ocasionará um erro de compilação, pois
A
a variável “x” não foi inicializada.
B
a variável “x” foi modificada dentro do método “Func”.
C
o método “Func” foi invocado sem instanciar a classe “Program”.
D
o modificador de acesso do método “Func” foi omitido
E
a variável “x” não pode ser indicada como referência duas vezes na mesma chamada.
Em uma aplicação desenvolvida com C# um Analista de Sistemas criou a classe Conta com os atributos NumeroConta e Saldo. Em outra classe, instanciou um conjunto de objetos da classe Conta e armazenou em um array chamado vcontas. Para percorrer esse array exibindo o saldo de cada conta, o Analista deverá utilizar o comando
A
for(int i = 1; i < vcontas.lenght; i++) {MessageBox.Show("saldo = " + vcontas[i].Saldo);}
B
foreach(Conta c in vcontas){MessageBox.Show("saldo = " + c.Saldo);}
C
int i=0; do{MessageBox.Show("saldo = " + vcontas[i].Saldo);} while(i<=vcontas.Length);
D
foreach(Conta c in vcontas){JOptionPane.ShowMessageBox("saldo = " + c.Saldo);}
E
int i=0; while(i<=vcontas.lenght){MessageBox.Show("saldo = " + vcontas[i].Saldo); i++;}
Em um ambiente de desenvolvimento .NET utilizando C#, assinale a alternativa que contém o caractere especial que deve ser utilizado no início de uma string, logo após o operador de atribuição, para realizar interpolação de strings.
A
!
B
&
C
$
D
#
E
@
Herança e interfaces são conceitos da orientação a objetos que permitem, respectivamente, a reutilização de código e o estabele-cimento de contratos de obrigatoriedade na implementação de certas funcionalidades. Em C#,
A
métodos declarados em uma interface só podem ser públicos ou protegidos e não podem possuir implementação.
B
para declarar que uma classe chamada PessoaJuridica implementa uma interface chamada ITributavel utiliza-se o comando public class PessoaJuridica: implements ITributavel { }.
C
interfaces são mais complexas do que classes já que necessitam de atributos e métodos com implementação e sintaxe diferenciada.
D
herança múltipla (quando uma subclasse é filha de mais de uma superclasse) não é suportada, porém, cada classe pode implementar diversas interfaces diferentes.
E
para declarar que a classe chamada Funcionario herda a classe Pessoa e implementa a interface ITributável utiliza-se o comando public class Funcionario extends Pessoa: implements ITributavel { }.
Em relação à sobrecarga de operadores em C#, é INCORRETO afirmar:
A
Os operadores são declarados públicos.
B
Os operadores são declarados estáticos.
C
Os operadores não são polimórficos e não podem utilizar os modificadores virtual, abstract, override ou sealed.
D
Os operadores apresentam ausência do parâmetro this oculto.
E
A precedência e a associatividade dos operadores sobrecarregados são redefinidas pelo programador.
Considere as declarações de classes e interfaces C# a seguir:
class a { }
class b { }
interface c { }
interface d { }
Com base nessas declarações, é válida a declaração da classe:
A
class e : a, c, d { }
B
class f : c, b, d { }
C
class g : a, b, c, d { }
D
class h : a, b { }
E
class i : c, d, a { }
Um desenvolvedor escreveu o seguinte programa em C# e verificou que ele não podia ser compilado:
using System;
namespace ConsoleApp
{
class ConsoleApp
{
public static void Console() { /
public static void System() { /
public static void Main()
{
Console.WriteLine(“xpto”);
}
}
}
Para que esse programa possa ser compilado, é necessário alterar o método Main para:
A
public static void Main(){
global::Console.WriteLine(“xpto”);
}
B
public static void Main(){
with (global::System){
Console.WriteLine(“xpto”);
}
}
C
public static void Main(){
using (global::System){
Console.WriteLine(“xpto”);
}
}
D
public static void Main(){
System.Console.WriteLine(“xpto”);
}
E
public static void Main(){
global::System.Console.WriteLine(“xpto”);
}
Na linguagem de programação C#, a criação de objetos pode ser feita pelo operado:
A
dynamic.
B
malloc
C
new.
D
alloc.
Analise o código C# exibido a seguir:
using System;
namespace TESTE
{
--class Program
--{
----delegate int del(int i);
----static void Main(string[] args)
----{
------del myF = x => x * x;
------int j = myF(5); /
------Console.WriteLine(j.ToString());
----}
--}
}
O resultado produzido no console é:
A
5
B
25
C
False
D
True
E
x * x
Analise o código C# exibido a seguir:
using System;
namespace ENIGMA
{
--class Program {
----static void Main(string[] args) {
------P d = new P();
------d.PP();
------E s = new E();
------s.A();
------s.PP();
------Console.ReadKey();
----}
----class P {
------public void PP()
------{
--------Console.WriteLine("PP");
------}
----}
----class E : P {
------public void A()
------{
--------Console.WriteLine("A");
------}
----}
--}
}
O resultado produzido no console é:
A
PP
A
PP
B
PP
PP
C
A
PP
A
D
AA
P
AA
E
A
A
A
Todas as alternativas remetem a exemplos de tipos primitivos válidos da linguagem de programação C#, exceto:
A
decimal.
B
char.
C
ubyte.
D
ulong.
Na linguagem de programação C# a passagem de parâmetros pode ser realizada de quatro diferentes formas. Todas as alternativas remetem a opções válidas, exceto:
A
Value.
B
Params.
C
In.
D
Out.
Considere o código fonte abaixo, escrito em linguagem C, e analise as afirmativas abaixo.
#include <stdio.h>
#include <stdlib.h>
struct entrada_cadastro {
char name[50];
int idade;
};
int main(void)
{
struct entrada_cadastro *ptr;
ptr = malloc(sizeof(ptr));
if (ptr == NULL) {
printf(“falha na alocação de memória\n”);
return 1;
}
memset(ptr, 0x0, sizeof(*ptr));
strcpy(ptr->name, “Aluno”);
ptr->idade = 20;
return 0;
}
Marque (V) para verdadeiro ou (F) para falso.
( ) A alocação de memória, presente na função main, efetuada com a função malloc, resulta na mesma quantidade alocada em bytes que ptr = malloc(sizeof(struct entrada_cadastro)).
( ) A função strcpy copia a palavra Aluno para o vetor name da struct entrada_cadastro.
( ) O acesso aos campos da estrutura de dados é realizado através do ponteiro nomeado ptr de tipo struct entrada_cadastro.
A sequência correta é
A
V, F, F.
B
F, F, V.
C
V, V, V.
D
F, V, V.
E
V, V, F.
Gerar simulado