Creamos el proyecto:

Archivo / Nuevo / Proyecto

Seleccionamos tipo “Biblioteca de Clases”:

Dentro de la Biblioteca creada, agregamos las clases que nos piden:

Clic derecho en Bibilioteca / Agregar / Clase
Seleccionamos el tipo Clase y le damos un nombre:

Primero, crearemos la enumeraciones:

Eliminamos donde dice “class” y agregamos “public enum” seguido del nombre de nuestra enumeración,
en este caso “GeneroLibro”.

Anotamos las distintas categorías, con números correlativos, separados por coma.
También es posible crearlos sin número asignado, solo separados por coma. Esto hará que tomen los
valores de 0 a n… 0 para el primero, 1 para el segundo, y así.
Ahora crearemos la clase CopiaLibro.
Hacemos clic derecho en la Biblioteca y agregamos una nueva clase.

Seleccionamos el tipo “Clase” y le damos un nombre.

Creamos los campos de la Clase CopiaLibro, según el enunciado:

Creamos las propiedades de la clase CopiaLibro (que sirven para asignar y devolver valores).

En este caso, las excepciones enviarán el mensaje de validación a la interfaz de usuario que
programaremos más adelante.

Hacemos lo mismo para Ubicacion y Fecha Ingreso:

La fecha de revisión debe ser 6 meses después de la fecha de ingreso:

Luego creamos el método constructor de la clase, un método para darle valores iniciales y otro para
imprimir los datos.
Ahora, crearemos la segunda clase “Libro”, de la misma forma que la anterior.
Clic derecho en biblioteca, agregar clase.

Creamos los campos:

Y las propiedades:

En este caso, si el valor es nulo o está vacío, devolverá una excepción en forma de mensaje.
Lo mismo para el nombre:

Para el autor:

El género lo creamos con el tipo de enumeración definida anteriormente:

La editorial:

La cantidad de copias, será el largo del arreglo “registroCopias”.

Luego, creamos el constructor y el método para darle valores iniciales a los campos:
Finalmente, creamos un método para guardar las copias de los libros en un arreglo.
Aumentaremos en una posición el arreglo con Array.Resize().
Luego, guardamos la copia creada en el arreglo.
(Esta copia la enviaremos por parámetro desde la interfaz de usuario).

Ahora creamos las pantallas:

Para eso, vamos al explorador, hacemos clic derecho en la la solución TareaLibro y agregamos un
nuevo proyecto.

Será de tipo “WPF” y le daremos el nombre “WpfVariasPantallas”

Después, agregamos al proyecto WpfVariasPantallas, la referencia a la Biblioteca para poder utilizar las
clases Libro y CopiaLibro.

Clic derecho en el proyecto WpfVariasPantallas / agregar / referencia.

Luego, agregamos una nueva ventana de tipo WPF al proyecto “WpfVariasPantallas”
Clic derecho en el proyecto, agregar ventana.

En este caso, le daremos el nombre “MainWindow” (aunque puede ser cualquiera).

Agregamos la directiva “​using ​Biblioteca” en la cabecera del código de la pantalla principal.
Esto lo haremos en cada nueva pantalla que creemos.

Además, creamos un arreglo de Libro para ir guardando los libros creados en la interfaz de usuario.

Vamos al diseño (MainWindow.xaml) y agregamos tres botones para generar las pantallas que nos
piden:

No olvidar dar a cada botón un nombre, en las propiedades del control…

Ahora crearemos las tres ventanas que se desplegarán cuando se haga clic en los botones.
Clic derecho en WpfVariasPantallas / agregar / ventana

Seleccionamos el tipo WPF y le damos un nombre:

Hacemos lo mismo para las otras dos ventanas (​WpfListadoCopias​, ​WpfListadoLibros​).

Debería quedar así…

Luego, volvemos al diseño de la ventana principal y hacemos doble clic en cada uno de los tres
botones.
Se generarán tres métodos para programar el despliegue de las ventanas creadas.
Agregamos las líneas indicadas en las flechas.

En cada flecha vemos que se crea una nueva instancia de las clases correspondientes a las pantallas..
ShowDialog() mostrará la nueva pantalla creada.
Agregamos los siguientes controles a cada pantalla:

WpfIngresoLibro:

Label, para las etiquetas.

TextBox, para las cajas de texto.
DatePicker, para la fecha.
ComboBox, para el género.

Para WpfListadoLibro:
DataGrid, para la lista de libros.
Labe, para el titulo.

Para WpfListadoCopias:

ListBox, para la lista de copias.

Label, para el título.
*​No olvidar dar un nombre a cada control en las propiedades*
Estas son las convenciones para asignar nombres a los controles:
(Más que nada, para mantener orden y claridad al momento de utilizarlos.)
CheckBox → chk
ListBox → lst
DataGrid → dg
TextBox → txt
ComboBox → cbo
DatePicker → dp

*La abreviación seguida del nombre…*

Ahora que hemos hecho las pantallas, vamos a programar el despliegue y almacenamiento de los datos
desde los controles hacia los objetos de tipo Libro que crearemos.

Para la pantalla WpfIngresoLibro.xaml.cs:

Hacemos doble clic en el botón agregar, para generar el método:

Creamos las excepciones con Try y Catch.

Catch, retornará los mensajes de validación desde las clases Libro y CopiaLibro que creamos al
principio,
y los almacenará en ae.Message, para mostrarlos al usuario en caso de haber un error al validar los
datos.

Volvemos a la pantalla y hacemos clic en el botón agregar copia para generar el método y su
comportamiento:

Finalmente, creamos un método para limpiar los controles (dejarlos vacíos).

En la pantalla, WpfIngresoLibros.xaml.cs

A través del DataGrid creado “dg_ListadoLibros” accedemos a ItemSource y le asignamos el arreglo con
los registros guardados (MainWindow.registroLibros)
El datagrid se cargará automáticamente con todos los datos guardados en el arreglo registroLibros.

*​No olvidar ingresar la directiva “using Biblioteca” en la cabecera de cada clase*

En la pantalla WpfListadoCopias.xaml.cs:

Creamos el método que mostrará en la lista sólo las copias de libros que deben ser revisadas.
Es decir, aquellas que llevan más de 6 meses desde la fecha en que fueron ingresadas.

Y con esto, finalizamos y ejecutamos.