1. Libros
  2. C# 6 - Desarrolle aplicaciones Windows con Visual Studio 2015 - Versión online

C# 6 Desarrolle aplicaciones Windows con Visual Studio 2015 - Versión online

  • Acceso ilimitado 24/7
  • Todos los libros online de ENI
  • Más de 5 novedades todos los meses
  • Novedades disponibles el mismo día de su publicación
  • Acceso 100% online
  • Consulta inmediata
  • Versión HTML online
  • Acceso ilimitado 24/7

Presentación

Este libro sobre desarrollo de aplicaciones Windows con el lenguaje C# y Visual Studio 2015 está dirigido a los desarrolladores que comienzan con el framework .NET. Les permite aprender los conceptos principales del lenguaje C# e introduce conceptos más avanzados que les aportan una visión general de las posibilidades que ofrece el lenguaje C#, Visual Studio y el framework .NET en general. El autor ha seleccionado un enfoque paso a paso, construyendo una aplicación funcional a lo largo del libro para ilustrar de manera práctica y coherente los conceptos que se abordan.

El aprendizaje comienza familiarizándose con la interfaz de Visual Studio 2015 y con el concepto de arquitectura .NET. Antes de abordar el diseño de las interfaces de usuario, se explican los detalles del lenguaje C#, su sintaxis y todas sus funcionalidades, como las clases, la herencia, las interfaces, los tipos genéricos e incluso los delegados y los eventos.

El diseño de la interfaz de usuario cubre todas las fases necesarias para crear aplicaciones Windows funcionales y con buena ergonomía, desde la creación de formularios hasta la creación de controles, pasando por la implementación de administradores de eventos y la validación de los datos introducidos. También se incluye una introducción al diseño de aplicaciones WPF.

De la misma manera, se detallan las herramientas de Visual Studio que permiten realizar las pruebas y la depuración de las aplicaciones presentando las técnicas de gestión de errores y los conceptos que permiten monitorizar las aplicaciones, como la traza de la ejecución de la aplicación, la interacción con los registros de eventos y el uso de contadores de rendimiento.

Se detalla el uso del Entity Framework, usando ejemplos concretos que permiten entender rápidamente cómo crear modelos de datos y usarlos para establecer la comunicación con una base de datos, mientras se aprende el uso del lenguaje de consultas LINQ para interactuar con datos en diferentes formatos (objetos, SQL o XML). También se detalla la alternativa del almacenamiento de datos de una aplicación en el sistema de archivos, así como el uso del concepto de serialización, proporcionando, de esta manera, una visión global de las posibilidades que ofrece el framework .NET en lo que se refiere a la gestión de datos.

También se abordan conceptos más avanzados con el objetivo de exponer la gama más amplia de las posibilidades que ofrece el lenguaje C# y Visual Studio. Podemos citar algunos ejemplos, como el uso de expresiones regulares, el desarrollo de aplicaciones multitarea y asíncronas, la globalización y la localización de una aplicación, la seguridad del código, la implementación de aplicaciones cliente/servidor, el diseño con GDI+, así como la reflexión.

La última parte del libro está dedicada a la creación de ensamblados y al despliegue de las aplicaciones. Se detallan las herramientas y técnicas que ofrece Visual Studio para crear instaladores Windows y configurar las aplicaciones.

El código de la aplicación de ejemplo que se utiliza en el libro está disponible para su descarga en el sitio web www.ediciones-eni.com.

Los capítulos del libro:
Prólogo – Trabajar con Visual Studio 2015 – La arquitectura .NET – Introducción al lenguaje C# – La creación de tipos – La herencia – Tipos genéricos – Delegados, eventos y expresiones lambda – Creación de formularios – Implementación del administrador de eventos – Validar los datos introducidos – Creación de controles de usuario – Creación de aplicaciones Windows 8.1 – Depuración – Gestión de excepciones – Monitorización – Tests unitarios – Creación del modelo de datos – Presentación de Entity Framework – Presentación de LINQ – LINQ to Entities – LINQ to SQL – LINQ to XML – El sistema de archivos – Serialización – Expresiones regulares – Multi-threading – Globalización y localización – Seguridad – Para llegar más lejos – Ensamblados y configuraciones – Despliegue

Índice

  • Trabajar con Visual Studio
    • 1. Introducción
    • 2. La interfaz de desarrollo
      • 2.1 El editor de texto
      • 2.2 El diseñador de vistas
      • 2.3 El depurador integrado
      • 2.4 El administrador de extensiones
      • 2.5 NuGet
      • 2.6 Ventanas personalizadas
    • 3. La creación de soluciones
      • 3.1 Definir el punto de entrada
      • 3.2 La diferencia entre proyectos y soluciones
      • 3.3 Configurar el proyecto
      • 3.4 La conversión de soluciones
      • 3.5 Los proyectos compartidos
      • 3.6 Las herramientas de refactorización
  • La arquitectura .NET
    • 1. Introducción
    • 2. CLR
    • 3. Las bibliotecas de clases
    • 4. Los tipos
      • 4.1 Los tipos por valor
      • 4.2 Los tipos por referencia
  • Introducción al lenguaje C#
    • 1. La sintaxis
      • 1.1 Los identificadores
      • 1.2 Las palabras reservadas
      • 1.3 La reglas de puntuación
      • 1.4 Los operadores
        • 1.4.1 Los operadores de cálculo
        • 1.4.2 Los operadores de asignación
        • 1.4.3 Los operadores de comparación
      • 1.5 La declaración de variables
      • 1.6 Las instrucciones de control
        • 1.6.1 Las instrucciones condicionales
        • 1.6.2 Las instrucciones iterativas
        • 1.6.3 Las instrucciones de salto
      • 1.7 Los comentarios
    • 2. Los espacios de nombres
      • 2.1 La palabra reservada using
      • 2.2 La palabra reservada alias
      • 2.3 Las clases estáticas
    • 3. Los tipos básicos
      • 3.1 Los tipos numéricos
        • 3.1.1 Los enteros
        • 3.1.2 Los decimales
      • 3.2 Los booleanos
      • 3.3 Las cadenas de caracteres
      • 3.4 Los tipos null
      • 3.5 La conversión de tipos
        • 3.5.1 La conversión implícita
        • 3.5.2 La conversión explícita
    • 4. Las constantes y las enumeraciones
      • 4.1 Las constantes
      • 4.2 Las enumeraciones
    • 5. Los arrays
    • 6. Las colecciones
    • 7. Las directivas preprocesador
  • La creación de tipos
    • 1. Introducción
    • 2. Los niveles de acceso
    • 3. Las estructuras
    • 4. Las clases
      • 4.1 Los campos
      • 4.2 Las propiedades
      • 4.3 Los métodos
        • 4.3.1 La sobrecarga
        • 4.3.2 Los parámetros
      • 4.4 Los constructores
      • 4.5 Los destructores
      • 4.6 Las clases y miembros estáticos
      • 4.7 Las clases parciales
      • 4.8 La palabra reservada this
      • 4.9 Los indexadores
      • 4.10 La sobrecarga de operadores
        • 4.10.1 Los operadores aritméticos
        • 4.10.2 Los operadores de comparación
  • La herencia
    • 1. La herencia de clases
      • 1.1 Implementar la herencia
      • 1.2 Los miembros virtuales
      • 1.3 Ocultar los miembros heredados
      • 1.4 La palabra reservada base
      • 1.5 Las clases y miembros abstractos
      • 1.6 Las clases y los métodos cerrados
      • 1.7 Los constructores derivados
      • 1.8 El polimorfismo
    • 2. Las interfaces
      • 2.1 La implementación de interfaces
      • 2.2 El polimorfismo de interfaz
      • 2.3 La herencia de interfaces
  • Tipos genéricos
    • 1. Introducción
    • 2. La creación de tipos genéricos
    • 3. Las restricciones de tipo
    • 4. Las interfaces genéricas
      • 4.1 La varianza en las interfaces genéricas
        • 4.1.1 La covarianza
        • 4.1.2 La contravarianza
      • 4.2 La creación de interfaces genéricas variantes
      • 4.3 La herencia de interfaces genéricas variantes
    • 5. La creación de métodos genéricos
    • 6. Valor por defecto genérico
    • 7. La herencia de clase genérica
  • Delegados, eventos y expresiones lambda
    • 1. Los delegados
      • 1.1 Los parámetros de método
      • 1.2 Los métodos de destino múltiples
      • 1.3 Los delegados genéricos
      • 1.4 La compatibilidad de los delegados
    • 2. Los eventos
    • 3. Las expresiones lambda
      • 3.1 El uso de las expresiones lambda
      • 3.2 Los delegados genéricos
      • 3.3 La captura de variables
  • Creación de formularios
    • 1. Utilizar los formularios
      • 1.1 Añadir formularios al proyecto
      • 1.2 Modificar el formulario de inicio
      • 1.3 Las propiedades de los formularios
      • 1.4 Los métodos de los formularios
      • 1.5 Los eventos de los formularios
    • 2. Usar los controles
      • 2.1 Los tipos de controles
      • 2.2 Añadir controles a los formularios
      • 2.3 Las propiedades de los controles
      • 2.4 Los menús
      • 2.5 Los contenedores
      • 2.6 La usabilidad
      • 2.7 Añadir controles a la caja de herramientas
  • Implementación del administrador de eventos
    • 1. Introducción
    • 2. La creación de controladores de eventos
      • 2.1 La mecánica de un evento
      • 2.2 La adición dinámica de un controlador de eventos
      • 2.3 La eliminación dinámica de un controlador de eventos
    • 3. Los controladores de eventos avanzados
      • 3.1 Un controlador para varios eventos
      • 3.2 Varios controladores para un evento
  • Validar los datos introducidos
    • 1. Introducción
    • 2. La validación a nivel de campos
      • 2.1 Las propiedades de validación
      • 2.2 Los eventos de validación
        • 2.2.1 KeyDown y KeyUp
        • 2.2.2 KeyPress
        • 2.2.3 Validating y Validated
    • 3. La validación a nivel de formulario
    • 4. Los métodos de retorno al usuario
      • 4.1 MessageBox
      • 4.2 ErrorProvider
  • Creación de controles de usuario
    • 1. Introducción
    • 2. Los controles personalizados
    • 3. La herencia de controles
    • 4. Los controles de usuario
  • Creación de aplicaciones Windows 8.1
    • 1. Introducción
    • 2. Principios
    • 3. Las herramientas de desarrollo
    • 4. El lenguaje XAML
    • 5. Una primera aplicación Windows WPF
      • 5.1 Bases de un proyecto WPF
      • 5.2 Controles y eventos
  • Depuración
    • 1. Los tipos de error
      • 1.1 Los errores de sintaxis
      • 1.2 Los errores de ejecución
      • 1.3 Los errores de lógica
    • 2. El depurador
      • 2.1 Controlar la ejecución
      • 2.2 Los puntos de interrupción
        • 2.2.1 Las condiciones de parada
        • 2.2.2 El número de llamadas
        • 2.2.3 El filtro
        • 2.2.4 Las acciones
      • 2.3 Los DataTips
      • 2.4 Los PerfTips
      • 2.5 Los atributos Caller
    • 3. Las ventanas
      • 3.1 La ventana Resultados
      • 3.2 La ventana Variables locales
      • 3.3 La ventana Automático
      • 3.4 La ventana Inspección
      • 3.5 La ventana Inmediato
      • 3.6 Las otras ventanas
  • Gestión de excepciones
    • 1. La clase Exception
    • 2. La creación de excepciones personalizadas
    • 3. El desencadenamiento de excepciones
    • 4. La intercepción y gestión de excepciones
  • Monitorización
    • 1. La monitorización de la ejecución
      • 1.1 Las clases Debug y Trace
      • 1.2 El listener
        • 1.2.1 La creación de listeners
        • 1.2.2 La copia de seguridad de las trazas
      • 1.3 Los modificadores de seguimiento
        • 1.3.1 El funcionamiento de los modificadores de seguimiento
        • 1.3.2 La configuración de los modificadores de seguimiento
    • 2. Los archivos de traza de eventos
      • 2.1 La interacción con los archivos de traza de eventos
      • 2.2 La gestión de los archivos de traza de eventos
      • 2.3 La escritura de eventos
    • 3. Los contadores de rendimiento
      • 3.1 La creación de contadores de rendimiento
        • 3.1.1 Desde Visual Studio
        • 3.1.2 Desde el código
      • 3.2 El uso de contadores de rendimiento
      • 3.3 El análisis de contadores de rendimiento
  • Tests unitarios
    • 1. Introducción a las pruebas unitarias
      • 1.1 La creación del proyecto
      • 1.2 Las clases de pruebas unitarias
    • 2. La puesta en marcha de una serie de pruebas
      • 2.1 Crear pruebas del proyecto
      • 2.2 Los IntelliTests
      • 2.3 El desarrollo de las pruebas
  • Creación del modelo de datos
    • 1. Introducción
    • 2. La creación de un modelo
    • 3. La creación de entidades
    • 4. La generación de la base de datos
    • 5. La creación de entidades a partir de código (Code First)
  • Presentación de Entity Framework
    • 1. Introducción
    • 2. El mapeo
      • 2.1 La capa lógica
      • 2.2 La capa conceptual
      • 2.3 La capa de mapeo
    • 3. Trabajar con las entidades
      • 3.1 Las entidades
      • 3.2 La clase ObjectContext
      • 3.3 Las relaciones
        • 3.3.1 El concepto de tabla por tipo
        • 3.3.2 El concepto de tabla por jerarquía
  • Presentación de LINQ
    • 1. Las consultas LINQ
      • 1.1 La sintaxis
      • 1.2 Los métodos extendidos
    • 2. Los operadores de consultas
      • 2.1 Filtrar
        • 2.1.1 Where
        • 2.1.2 OfType<TResult>
        • 2.1.3 SelectMany
        • 2.1.4 Skip y Take
      • 2.2 Ordenar
        • 2.2.1 OrderBy
        • 2.2.2 ThenBy
      • 2.3 Agrupar
        • 2.3.1 GroupBy
        • 2.3.2 Join
      • 2.4 Agregar
      • 2.5 Convertir
    • 3. Las consultas paralelas
      • 3.1 Particionar una consulta
      • 3.2 Anular una consulta
  • LINQ to Entities
    • 1. Introducción
    • 2. Extraer datos
      • 2.1 La extracción simple
      • 2.2 La extracción condicional
    • 3. Añadir, modificar y eliminar datos
      • 3.1 Añadir datos
      • 3.2 Modificar datos
      • 3.3 Eliminar datos
      • 3.4 El envío de las modificaciones
  • LINQ to SQL
    • 1. La creación de clases LINQ to SQL
    • 2. El objeto DataContext
      • 2.1 El método ExecuteQuery
      • 2.2 Utilizar las transacciones
      • 2.3 Los demás miembros de DataContext
    • 3. Ejecutar las consultas con LINQ
      • 3.1 Las consultas sencillas
      • 3.2 Las consultas filtradas
      • 3.3 Los joins
    • 4. Los procedimientos almacenados
      • 4.1 La adición de procedimientos almacenados al modelo
      • 4.2 La ejecución de procedimientos almacenados
  • LINQ to XML
    • 1. Los objetos XML
      • 1.1 XDocument
      • 1.2 XElement
      • 1.3 XNamespace
      • 1.4 XAttribute
      • 1.5 XComment
    • 2. Ejecutar consultas con LINQ
      • 2.1 Las consultas sencillas
      • 2.2 Las consultas filtradas
      • 2.3 Los joins
  • El sistema de archivos
    • 1. Las clases de gestión del sistema de archivos
      • 1.1 DriveInfo
      • 1.2 Directory y DirectoryInfo
      • 1.3 File y FileInfo
      • 1.4 Path
    • 2. Trabajar con el sistema de archivos
      • 2.1 Los objetos Stream
      • 2.2 La clase FileStream
      • 2.3 Leer un archivo de texto
        • 2.3.1 Leer mediante la clase File
        • 2.3.2 Leer con la clase StreamReader
      • 2.4 Escribir en un archivo de texto
        • 2.4.1 Escribir mediante la clase File
        • 2.4.2 Escribir con la clase StreamWriter
  • Serialización
    • 1. Introducción
    • 2. La serialización binaria
      • 2.1 Conceptos básicos
      • 2.2 Controlar la serialización
        • 2.2.1 El control por atributo
        • 2.2.2 El control por interfaz
    • 3. La serialización XML
      • 3.1 Los conceptos básicos
      • 3.2 Controlar la serialización
      • 3.3 La serialización XML SOAP
  • Expresiones regulares
    • 1. Introducción
    • 2. Una primera expresión regular
    • 3. Las opciones de búsqueda
    • 4. Los caracteres de escape
    • 5. Los conjuntos
    • 6. Los grupos
    • 7. Los anchors
    • 8. Los cuantificadores
  • Multi-threading
    • 1. Introducción
    • 2. La clase Thread
      • 2.1 Crear un thread
      • 2.2 Suspender o anular un thread
      • 2.3 Intercambiar datos con un thread
      • 2.4 Bloquear un thread
      • 2.5 Prioridad de los threads
    • 3. Funciones asíncronas
      • 3.1 Task y Task<TResult>
      • 3.2 async y await
    • 4. El componente BackgroundWorker
  • Globalización y localización
    • 1. Introducción
    • 2. La cultura
    • 3. La globalización
    • 4. La localización
  • Seguridad
    • 1. Introducción
    • 2. Los elementos básicos
      • 2.1 La interfaz IPermission
      • 2.2 La clase CodeAccessPermission
      • 2.3 La interfaz IPrincipal
    • 3. Implementación de la seguridad
      • 3.1 La seguridad basada en roles
        • 3.1.1 Seguridad obligatoria
        • 3.1.2 Seguridad declarativa
      • 3.2 La seguridad basada en permisos de acceso
        • 3.2.1 Seguridad obligatoria
        • 3.2.2 Seguridad declarativa
    • 4. Introducción a la criptografía
  • Para llegar más lejos
    • 1. El diseño con GDI+
      • 1.1 La clase Graphics
        • 1.1.1 Las coordenadas
        • 1.1.2 Las formas
      • 1.2 La estructura Color y las clases Brush y Pen
        • 1.2.1 La estructura Color
        • 1.2.2 La clase Brush
        • 1.2.3 La clase Pen
        • 1.2.4 Los argumentos de sistema
      • 1.3 Los ejemplos
        • 1.3.1 La visualización de texto
        • 1.3.2 Redimensionar una imagen
    • 2. El remoting
      • 2.1 Introducción
      • 2.2 La implementación
        • 2.2.1 La capa común
        • 2.2.2 La aplicación servidor
        • 2.2.3 La aplicación cliente
    • 3. La reflexión
      • 3.1 La clase System.Type
      • 3.2 Cargar un ensamblado de manera dinámica
        • 3.2.1 La enumeración de los tipos
        • 3.2.2 La instanciación de objetos
        • 3.2.3 El uso de los miembros
  • Ensamblados y configuraciones
    • 1. Introducción
    • 2. Los ensamblados privados
    • 3. Los ensamblados compartidos
    • 4. Los archivos de configuración
  • Despliegue
    • 1. Introducción
    • 2. Los proyectos de despliegue
      • 2.1 XCOPY
      • 2.2 Proyecto CAB
      • 2.3 Proyecto de módulo de combinación
      • 2.4 Proyecto de instalación
    • 3. El asistente de instalación
    • 4. Configuración del proyecto
      • 4.1 Las propiedades del proyecto
      • 4.2 Los editores de configuración
        • 4.2.1 Editor del sistema de archivos
        • 4.2.2 Editor del registro
        • 4.2.3 Editor de tipos de archivo
        • 4.2.4 Editor de la interfaz de usuario
        • 4.2.5 Editor de acciones personalizadas
        • 4.2.6 Editor de condiciones de inicio
    • índice

Autor

Jérôme HUGONMás información

Jérôme HUGON es desarrollador y consultor .NET desde hace varios años y está certificado por Microsoft en tecnologías .NET. Su experiencia en el desarrollo de sitios web ASP.NET y SharePoint, así como de aplicaciones Windows o Microsoft Surface, le permite ofrecer al lector un sólido conocimiento de los fundamentos del lenguaje C# y también una perfecta introducción a conceptos más avanzados para un uso óptimo del mismo.

Características

  • Nivel Medio a Experto
  • Publicación diciembre 2015
    • HTML
    • ISBN: 978-2-7460-9935-7
    • EAN: 9782746099357
    • Ref. ENI: LNEIT6C15VIS

Descargas

Al completar este formulario, acepta recibir información y comunicaciones comerciales sobre nuestros productos y servicios. Puede darse de baja de nuestra newsletter en cualquier momento. Si desea conocer más información acerca de nuestra política de protección de datos, pulse aquí.
  • Descargar los ejemplos del libro - Parte 1 (38,5 Mo)
  • Descargar los ejemplos del libro - Parte 2 (47,6 Mo)
  • Descargar los ejemplos del libro - Parte 3 (57,2 Mo)