|
viernes, 4 de junio de 2021
Libros Gratuitos de Web Code Geeks
miércoles, 2 de junio de 2021
[Ebook] Kubernetes to Cloud Native: Jumpstart your journey developing on GKE
La gente de Google Cloud me envio el siguiente email y se los quiero compartir :
|
martes, 1 de junio de 2021
String en C#
La clase string es sumamente importante dado que los usuarios se comunican por medio de texto. String es un objeto de tipo Cadena cuyo valor es texto. Internamente, el texto se almacena como una colección secuencial de solo lectura de objetos Char. No hay ningún carácter de terminación nula al final de una cadena C#; por lo tanto, una cadena C# puede contener cualquier número de caracteres nulos incrustados ('\ 0'). La propiedad Length de una cadena representa el número de objetos Char que contiene, no el número de caracteres Unicode.
En C #, la palabra clave string es un alias de String. Por lo tanto, string y String son equivalentes, y puede usar la convención de nomenclatura que prefiera. La clase String proporciona muchos métodos para crear, manipular y comparar cadenas de forma segura. Además, el lenguaje C# sobrecarga algunos operadores para simplificar las operaciones comunes de cadenas.
Puede declarar e inicializar cadenas de varias formas, como se muestra en el siguiente ejemplo:
Los strings son inmutables: no se pueden cambiar una vez creados. Todos los métodos de cadena y los operadores de C# que parecen modificar una cadena en realidad devuelven los resultados en un nuevo objeto de cadena. En el siguiente ejemplo, cuando el contenido de s1 y s2 se concatenan para formar una sola cadena, las dos cadenas originales no se modifican. El operador += crea una nueva cadena que contiene los contenidos combinados. Ese nuevo objeto se asigna a la variable s1, y el objeto original que se asignó a s1 se libera para la recolección de basura porque ninguna otra variable tiene una referencia a él.
Se debe utilizar el carácter "\" cuando tengamos que usar caracteres especiales, como se muestra en el siguiente ejemplo:
Utilice cadenas textuales para mayor comodidad y mejor legibilidad cuando el texto de la cadena contiene caracteres de barra invertida, por ejemplo, en las rutas de archivo. Dado que las cadenas textuales conservan los caracteres de nueva línea como parte del texto de la cadena, se pueden utilizar para inicializar cadenas de varias líneas. Utilice comillas dobles para insertar una comilla dentro de una cadena literal. El siguiente ejemplo muestra algunos usos comunes de cadenas textuales:
Dejo link: https://docs.microsoft.com/en-us/dotnet/api/system.string?view=net-5.0
domingo, 30 de mayo de 2021
Libros Gratuitos de Java Code Geeks
Download IT Guides!
|
|
lunes, 24 de mayo de 2021
Go in Action Gratis hasta el 30 de Mayo!!
Manning nos regala Go in Action hasta el 30 de mayo, miren:
- Full-length 264 page book
- Language features and implementation
- Go's type system
- Internals of Go's data structures
Dejo link:
domingo, 23 de mayo de 2021
Libro gratuitos de Web code Geeks
|
sábado, 22 de mayo de 2021
Strings y Arrays de Bytes en Go
Los strings y los arrays de bytes están muy relacionados. Podemos convertir de uno a otro fácilmente:
stra := "the spice must flow"
byts := []byte(stra)
strb := string(byts)
De hecho, este tipo de conversión es común también entre otros tipos. Algunas funciones esperan explícitamente un int32 o un int64 o sus homólogos sin signo. Puede que te descubras a ti mismo haciendo cosas como esta:
int64(count)
Es algo que probablemente acabes haciendo con frecuencia cuando utilices bytes y strings. Observa que cuando utilizas []byte(X) o string(X) estás haciendo una copia de los datos. Esto es imprescindible ya que los strings son inmutables.
Los strings están hechos de runas, que son letras unicode. Si recuperas la longitud de un string es probable que no obtengas el valor que esperas. El código siguiente muestra 3:
fmt.Println(len("")) // quizá no lo veas, aquí debería aparecer un carácter chino
Si iteras sobre un string utilizando range obtendrás las runas, no los bytes, aunque cuando conviertes un string en un []byte obtienes los datos correctos.
jueves, 20 de mayo de 2021
Propiedades en C#
Una propiedad es un miembro que proporciona un mecanismo flexible para leer, escribir o calcular el valor de un campo privado. Las propiedades se pueden usar como si fueran miembros de datos públicos, pero en realidad son métodos especiales llamados descriptores de acceso. Esto permite acceder fácilmente a los datos y aún así ayuda a promover la seguridad y flexibilidad de los métodos.
Las propiedades permiten que una clase exponga una forma pública los get y set, mientras oculta el código de implementación o verificación.
Se usa un descriptor de acceso de propiedad para devolver el valor de la propiedad, y se usa un descriptor de acceso de propiedad establecido para asignar un nuevo valor. Por ejemplo si queremos un atributo solo lectura y otro que se pueda acceder y asignar :
class Persona {
public long Dni { get; }
public string Nombre { get; set; }
public string Apellido { get; set; }
...
La palabra clave value se utiliza para definir el valor asignado por el descriptor de acceso set o init.
Las propiedades pueden ser de lectura y escritura (tienen un descriptor de acceso get y set), de solo lectura (tienen un descriptor de acceso get pero no un descriptor de acceso establecido) o de solo escritura (tienen un descriptor de acceso set, pero no un descriptor de acceso get). Las propiedades de solo escritura son raras y se utilizan con mayor frecuencia para restringir el acceso a datos confidenciales.
Las propiedades simples que no requieren un código de acceso personalizado se pueden implementar como definiciones de cuerpo de expresión o como propiedades implementadas automáticamente.
Un patrón básico para implementar una propiedad implica el uso de un campo de respaldo privado para establecer y recuperar el valor de la propiedad. El descriptor de acceso get devuelve el valor del campo privado, y el descriptor de acceso establecido puede realizar alguna validación de datos antes de asignar un valor al campo privado. Ambos accesadores también pueden realizar alguna conversión o cálculo en los datos antes de que se almacenen o devuelvan.
Veamos un ejemplo :
using System;
class TimePeriod
{
private double _seconds;
public double Hours
{
get { return _seconds / 3600; }
set {
if (value < 0 || value > 24)
throw new ArgumentOutOfRangeException(
$"{nameof(value)} must be between 0 and 24.");
_seconds = value * 3600;
}
}
}
class Program
{
static void Main()
{
TimePeriod t = new TimePeriod();
// The property assignment causes the 'set' accessor to be called.
t.Hours = 24;
// Retrieving the property causes the 'get' accessor to be called.
Console.WriteLine($"Time in hours: {t.Hours}");
}
}
// The example displays the following output:
// Time in hours: 24
Los descriptores de acceso a las propiedades a menudo consisten en declaraciones de una sola línea que simplemente asignan o devuelven el resultado de una expresión. Puede implementar estas propiedades como miembros con cuerpo de expresión. Las definiciones del cuerpo de la expresión consisten en el símbolo => seguido de la expresión para asignar o recuperar de la propiedad.
A partir de C # 6, las propiedades de solo lectura pueden implementar el descriptor de acceso get como un miembro con cuerpo de expresión. En este caso, no se utiliza ni la palabra clave get accessor ni la palabra clave return. El siguiente ejemplo implementa la propiedad Name de solo lectura como un miembro con cuerpo de expresión.
using System;
public class Person
{
private string _firstName;
private string _lastName;
public Person(string first, string last)
{
_firstName = first;
_lastName = last;
}
public string Name => $"{_firstName} {_lastName}";
}
public class Example
{
public static void Main()
{
var person = new Person("Magnus", "Hedlund");
Console.WriteLine(person.Name);
}
}
// The example displays the following output:
// Magnus Hedlund
A partir de C # 7.0, tanto el descriptor de acceso get como el set se pueden implementar como miembros con cuerpo de expresión. En este caso, las palabras clave get y set deben estar presentes. El siguiente ejemplo ilustra el uso de definiciones de cuerpo de expresión para ambos descriptores de acceso. Tenga en cuenta que la palabra clave return no se usa con el descriptor de acceso get.
using System;
public class SaleItem
{
string _name;
decimal _cost;
public SaleItem(string name, decimal cost)
{
_name = name;
_cost = cost;
}
public string Name
{
get => _name;
set => _name = value;
}
public decimal Price
{
get => _cost;
set => _cost = value;
}
}
class Program
{
static void Main(string[] args)
{
var item = new SaleItem("Shoes", 19.95m);
Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
}
}
// The example displays output like the following:
// Shoes: sells for $19.95
En algunos casos, los descriptores de acceso de propiedad get y set simplemente asignan un valor o recuperan un valor de un campo de respaldo sin incluir ninguna lógica adicional. Al usar propiedades implementadas automáticamente, puede simplificar su código mientras el compilador de C# le proporciona de manera transparente el campo de respaldo.
Si una propiedad tiene tanto un descriptor de acceso get como un set (o un get y un init), ambos deben implementarse automáticamente. Usted define una propiedad implementada automáticamente usando las palabras clave get y set sin proporcionar ninguna implementación. El siguiente ejemplo repite el anterior, excepto que Nombre y Precio son propiedades implementadas automáticamente. El ejemplo también elimina el constructor parametrizado, por lo que los objetos SaleItem ahora se inicializan con una llamada al constructor sin parámetros y un inicializador de objeto.
using System;
public class SaleItem
{
public string Name
{ get; set; }
public decimal Price
{ get; set; }
}
class Program
{
static void Main(string[] args)
{
var item = new SaleItem{ Name = "Shoes", Price = 19.95m };
Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
}
}
// The example displays output like the following:
// Shoes: sells for $19.95
Dejo link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
lunes, 17 de mayo de 2021
Delegate en C# parte 3
Los Generic Delegate no requieren la definición de una instancia de un delegado para invocar a los métodos.
Existen tres tipos de Generic delegate:
Generic Delegate: Func
El delegado Func define un método que puede ser llamado con argumentos y devolver un valor. Existen varias sobrecargas de este delegado.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
// Definir el delegado Func con parámetro de entrada de tipo int y devuelve un string
Func<int, string> showIntToString = delegate(int i)
{
return i.ToString();
};
// Definir el delegado Func con parámetro de entrada de tipo string y devuelve un int
Func<string, int> showStringToInt = s =>
{
return int.Parse(s);
};
// Llamar a los delegados
Console.WriteLine(showIntToString(16));
Console.WriteLine(showStringToInt("55"));
}
}
El delegado Action define un método que puede ser llamado con argumentos pero NO devuelve un valor. Existen varias sobrecargas de este delegado.
Un ejemplo básico de este delegado podría ser:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
// Definir el delegado Action con parámetro de entrada de tipo int
Action<int> showIntToString = delegate(int i)
{
Console.WriteLine("El valor pasado al delegado como parámetro es: {0}", i);
};
// Definir el delegado Action con parámetro de entrada de tipo string
Action<string> showStringToInt = s =>
{
Console.WriteLine("El valor pasado al delegado como parámetro es: {0}", s);
};
// Llamar a los delegados
showIntToString(16);
showStringToInt("55");
}
}
El delegado Predicate define un método que puede ser llamado con argumentos pero SIEMPRE devuelve un valor de tipo bool. Existen varias sobrecargas de este delegado.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
string validNumber = "28";
string invalidNumber = "28z";
// Definir el delegado Predicate con parámetro de entrada de string
Predicate<string> isValidNumber = d => IsNumber(d);
if (isValidNumber(validNumber))
{
Console.WriteLine("El número {0} es válido", validNumber);
}
else
{
Console.WriteLine("El número {0] NO es válido", validNumber);
}
if (isValidNumber(invalidNumber))
{
Console.WriteLine("El número {0} es válido", invalidNumber);
}
else
{
Console.WriteLine("El número {0} NO es válido", invalidNumber);
}
}
private static bool IsNumber(string number)
{
Decimal d;
return Decimal.TryParse(number, out d);
}
}
Interfaces Vacías y Conversiones en Go
En la mayoría de los lenguajes orientados a objetos hay una clase base predefinida, a menudo llamada object, que actúa como superclase de todas las clases. Esto es lo que ocurre con una interfaz vacía sin métodos: interface{} en go. Puesto que las interfaces se implementan implícitamente, todos los tipos encajan con el contrato de una interfaz vacía.
Si quisiéramos podríamos crear una función llamada add con la siguiente firma:
func add(a interface{}, b interface{}) interface{} {
...
}
Por lo que podriamos utilizar esta función con cualquier tipo. Pero si nosotros necesitamos hacer diferentes acciones por tipo podemos convertir los tipos.
Para convertir una variable a un tipo específico debes usar .(TIPO):
return a.(int) + b.(int)
También puedes crear switchs de tipos:
switch a.(type) {
case int:
fmt.Printf("a es un entero y vale %d\n", a)
case bool, string:
// ...
default:
// ...
}
Sé que no es una solución elegante pero muchas veces viene bien.
