- Unir cadenas con comas
-
Hace unos dias Eric publico un problema, al principio me dio flojera responderlo, pero al ver el numero de respuestas decidi hacerlo agregando el reto personal de ser la respuesta mas corta (con mi equipo anterior competiamos en ver quien podia refactorizar mas), asi que aqui esta:
El problema:
Escribir una funcion que tome un IEnumerable no nulo y regrese una cadena con las siguentes caracteristicas: (1) Si la secuencia esta vacia, regresar "{}".
(2) Si la secuencia contiene un solo elemento "ABC" el resultado sera "{ABC}".
(3) Si la secuencia contiene 2 elementos "ABC", "DEF" El resultado sera "{ABC and DEF}".
(4) Si la secuencia contiene mas de 2 elementos "ABC", "DEF", "G", "H" el resultado sera "{ABC, DEF, G and H}". (Noten que los ultimos 2 elementos no estan unidos por coma)
Mi solucion:
static string JoinStrings(IEnumerable<string> strings) {
int len = strings.Count();
return len == 0 ? "{}"
: len == 1 ? "{"+strings.First()+"}"
: "{"+strings.Take(len - 1).Aggregate((string head, string tail) => head+", "+tail)+" and " +strings.Last()+"}";
}
Por cierto, si solo quisieramos unir las cadenas con comas (y regresar una cadena vacia cuando no hay elementos), pudieramos utilizar esto:
static string JoinStrings2(IEnumerable<string> strings) {
return strings.Count() > 0 ?
strings.Aggregate((string h, string t) => h+", "+t)
:
"";
}
- Los miembros de una interface SI pueden ser privados
-
Este dato sorprende a la mayoria, cualquiera que ha aprendido a usar interfaces sabe que la primera regla es que todos los miembros son publicos y por ende su implementacion tambien lo es, siempre, no es opcional. Al menos hasta que llegaste a este articulo a desaprender que eso no es totalmente cierto. Veamos un pequeño ejemplo, con el puro proposito de demostrarlo.
public interface ITest {
void Test();
}
public class Test : ITest {
void ITest.Test() { //<
Console.WriteLine("test");
}
public void Test2() {
Console.WriteLine("test2");
}
}
class Program {
static void Main(string[] args) {
ITest t = new Test();
t.Test();
Test t2 = new Test();
//t2.Test(); //<<=== no compila
Si no lo crees puedes intentarlo tu mismo.
Pero de que me sirve o para que puedo usar esto?
La tecnica te permite asegurarte que el metodo solo es visible a aquellos que usen una variable del tipo de la interface (ITest en este caso). Lo unico que hace es forzar a que el uso de ese metodo sea a travez de una instancia de la interface, osea que, para este ejemplo, si quieres acceder al metodo .Test, solo lo puedes hacer a travez de una variable del tipo ITest.
El unico "truco" para lograr esto es que en la declaracion tienes que agregar el tipo de la interface, antes del miembro:
void ITest.Test();
Seguramente no es el truco mas util, pero es algo para tenerlo guardado ahi en el cofre de los trucos y que en algun momento te sera de utilidad, o talvez algo que te pueda hacer ganar una apuesta ;)
- Lo que quisiera ver en la siguiente version de C#
-
Mitch Denny escribio sobre lo que el quisiera para la siguiente version de C# (mucha otra gente ha escrito sobre este tema ultimamente)
Lo que Mitch propone es tener un atajo para formatear strings, lo cual nos permitiria ir de algo asi
string s=string.Format(”{0}{1}{2}”, a, b, c);
a esto:
string s=@(”{0}{1}{2}”|a|b|c);
En este caso particular no me gusta la alternativa que propone, lo unico que esta haciendo es reemplazar la "," con el caracter "|" y haciendo el nombre mas corto.
Uno podria escribir su propia funcion "de envoltura":
//*** podrias llamarla "f" si quisieras
static string fmt(string format, params object[] parameters) {
return string.Format(format, parameters);
}
y la usarias asi:
string s=fmt("{0}{1}{2}",a,b,c);
Lo cual nos da practicamente el mismo resultado que lo propuesto por Mitch
Otro problema es que esta propuesta resuelve un problema muy especifico el cual es formatear strings y podemos obtener casi el mismo resultado escribiendo una funcioncita
El caso es que con tanta gente dando su opinion sobre lo que les gustaria ver en la siguiente version de C#, pues yo tambien tengo mi idea
lista de argumentos sin coma
algo asi:
string s=fmt("{0}{1}{2}" a b c);
El alcance de este cambio seria muchisimo mayor y de hecho le quitaria algo de "azucar de sintaxis" (syntactic sugar) al lenguaje
Ahora bien, este cambio seguramente no ocurrira, debido a que esta es la familia de los lenguajes C y ademas me parese que el cambio seria bastante significativo, pero como este es mi blog pues yo pongo mi idea =o)
Por cierto una de las ideas que me ha parecido buena es la de tener argumentos nombrados, con lo cual se podrian mandar llamar funciones de la manera
AlgunaFuncion(Parametro1 = "Algun valor", Parametro2=10);
Esta idea me parece excelente, una de las cosas que eliminaria seria la confusion que generan los parametros booleanos, y ya no tendriamos que usar Enum para esos casos
- C# vNext wishlist: comma less argument list
-
Mitch Denny has a post about his feature request for the next version of C#
he wants to have a shortcut to format strings, which would basically allow you to go from this
string s=string.Format(”{0}{1}{2}”, a, b, c);
to this:
string s=@(”{0}{1}{2}”|a|b|c);
I don't think I like the proposed alternative, all you are doing is replacing the "," with the "|" character and making the name shorter.
You could always write your own little wrapper:
//*** you could call it "f" if you wanted
static string fmt(string format, params object[] parameters) {
return string.Format(format, parameters);
}
and get
string s=fmt("{0}{1}{2}",a,b,c);
which is almost the same as the proposed solution
another problem is that this proposal solves a very particular problem which is string formatting and we can get pretty much the same by writing our own little wrapper
but anyway, it gave me an idea for my own feature request
comma-less arguments
string s=fmt("{0}{1}{2}" a b c);
The scope of this change is much wider and actually "desugars" the language
now this change will most likely not happen, since this is a C family language and would take a significant change to the parser but this is my own wish/feature request so there you have it
- Obtener el ultimo dia del mes
-
Aplica a: C#, .NET
Entrando en la onda de compartir codigo, y creo que es la segunda vez en esta semana que necesito esta funcion
DateTime GetLastDayOf(DateTime date) {
return new DateTime(date.Year, date.Month, DateTime.DaysInMonth(date.Year, date.Month));
}
- C# trivia #1: overloads, strings, nullable types
-
esta entra sirve a la vez para probar el mas reciente Windows Live Writer
Tenemos estas clase:
public class Foo {
public void Bar(string x) {
Console.WriteLine("string x was called");
}
public void Bar(int? x) {
Console.WriteLine("int? x was called");
}
}
cual sera la salida a la consola con el siguiente codigo:
Foo f = new Foo();
try {
f.Bar(null);
}
catch {
Console.WriteLine("no method was called");
}
- control activeX en .NET no funciona bajo https
-
keywords: .net user control, activex, ocx, IE7, IE, https, http, seguro
Justin y yo tuvimos una semana muy pesada peleandonos con unos controles ActiveX desarrollados en C# y .NET 2.0, asi que vamos a postear algunas de nuestras experiencias con los problemas y soluciones que encontramos (para que podamos recordarlas despues), la prima es sobre controles ActiveX corriendo bajo https.
Desarrollamos el control, todo funcionaba muy bien, uno de nuestros clientes queria ese control en un sitio https, asi que dijimos no hay problema... hasta que tratamos, y tratamos, y tratamos y nada funcionaba, el control simplemente no cargaba correctamente (si cargaba, pero no hacia lo que necesitabamos, esto era aun peor).
La solucion resulto ser algo muy simple (como normalmente es el caso); cuando incluyes un control, normalmente se hace asi:
<object id="someId" classid="SomeDll#Namespace.ClassName"></object>
Esa es la forma en la que lo encuentras en los ejemplos en internet, y funciona muy bien (una vez que pasas todas las demas barreras para hacerlo funcionar) bajo http, pero cuando corres ese mismo sitio bajo https, el control simplemente no funciona.
la solucion?
Cuando creas tu control, le asignas un identificador unico (guid)
[Guid("CAE67AEA-F489-4e52-956B-CCC774F40A3A")]
[ClassInterface(ClassInterfaceType.None), ComSourceInterfaces(typeof(IControlEvents))] // --Expose events
[ComVisible(true)]
public partial class MyControl : UserControl...
mas o menos asi...
bien, para hacer que el control funcione en https, simplemente tendras que usar ese GUID, no el nombre de la clase, asi que escribiriamos el codigo html de la siguiente manera
<object id="someId" classid="clsid:CAE67AEA-F489-4e52-956B-CCC774F40A3A"></object>
listo, es todo lo que hay que hacer, espero que les hallamos evitado algunas horas de dolores de cabeza
salu2
- protected, internal, protected internal... de verdad sabes que hacen?
-
Este articulo aplica a C#
Todos creemos dominar los modificadores de acceso, pero me puedes decir lo que protected internal hace?
apuesto que mas de la mitad de los desarrolladores .NET contestarian incorrectamente, vamos a ver:
- private:
- Este es el nivel de acceso mas restrictivo.
- Es accesible solamente dentro del cuerpo de la clase o estructura en que esta declarado.
- Tipos declarados dentro (nested types) del mismo cuerpo de la clase tambien tienen acceso a los tipos privados.
- public:
- Este es el nivel de acceso con menos restricciones.
- No hay restricciones para accesar miembros publicos, son tan visibles como la clase.
- protected:
- El acceso es limitado a la clase que los contiene o a tipos derivados de la clase.
- Lo cual quiere decir que no puedes crear una instancia de esta clase y accesar los miembros protegidos.
- internal:
- El acceso esta limitado solo al assembly en donde la clase reside.
- protected internal:
- Acceso es limitado a el assembly donde la clase reside o a tipos derivados de la clase.
Este ultimo es bastante capcioso, a primera vista podria parecer que permite acceso solo dentro del assembly donde la clase reside y las clases derivadas, pero el "o" ahi es lo que hace la diferencia, si marcas una propiedad protected internal puede ser usada fuera del assembly actual. basicamente protected sobreescribe internal, asi que ni siquiera estoy seguro de cuando es que se podria usar tal modificador.
pero bueno, regresando al tema, si no me crees eso de protected internal, puedes verificar tu mismo:
Assembly1:
public class Test {
protected internal string prop1;
}
Assembly2://despues de agregar la referencia a Assembly 1
public class Test2: Test {
public string prop2;
public Test2() {
prop2 = prop1; //el acceso a prop1 viene de otro assembly, de un miembro protected internal
}
}
Si esto es nuevo para ti, podrias pensar que es absurdo, entonces como haces que una propiedad sea visible solo en el assembly actual y en las clases derivadas (pero solo de este assembly)?
Pues no es tan complicado, marcas la clase como internal, lo cual restringe el acceso solo al assembly actual, y luego marcas la propiedad como protected, lo cual resulta en acceso desde las clases derivadas pero solo dentro del assembly actual.:
internal class Test {
//accesible solo en este assembly y clases derivadas dentro de este assembly
protected string prop1;
} salu2
- formateando 0, 1 como si, no, etc
-
Esto es algo que todos (los programadores) hemos hecho alguna vez, convertir un valor 0, 1 al equivalente si o no, prendido o apagado, verdadero o falso, valor en un string
pues resulta que hay una funcion en el BCL con la cual podemos hacer exactamente eso, string.Format es dicha funcion
Console.WriteLine(string.Format("{0:si;;no}", 0)); //salida "no"
Console.WriteLine(string.Format("{0:si;;no}", 1)); //salida "si"
y nomas por ver que pasaba
Console.WriteLine(string.Format("{0:si;;no}", -1)); //salida "-si"
...Esas pequeñas cosas
- funcion para generar numeros aleatorios, con todos los digitos distintos
-
El codigo para este articulo aplica a C#
Leyendo blogs, me encontre con este post (en italiano), donde Marco quiere escribir una funcion que le genere numeros aleatorios de 5 digitos, el resultado se requiere en un string, donde todos los digitos son diferentes, es decir, cada numero (de 5 digitos) generado, no puede tener 2 digitos iguales, la funcion que el escribio es la siguiente:
private string GetRandom()
{
Random rn = new Random();
string resultnum=string.Empty;
do
{
string a = rn.Next(0, 9).ToString();
if (resultnum.Contains(a)!=true)
resultnum = resultnum + a;
}
while (resultnum.Lengthreturn resultnum;
}
Inmediatamente me dio curiosidad por ver que areas que podria mejorar, y me puse a escribir una funcion que obtuviera el mismo resultado, pero en forma mas optimizada
cosas que saltan a mi mente inmediatamente son:
- concatenacion de strings
- el loop y la comparacion para encontrar numeros que no tengamos previamente
Entonces lo que quise lograr en mi funcion es: evitar la concatenacion, y ejecutar el loop exactamente 5 veces, esto es el resultado:
static char[] allNumbers = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
Random r = new Random();
public string GetRandom2() {
char[] result = new char[5];
int max = 9, pos=0;
for (int i=1; i//*** swap positions
allNumbers[pos] ^= allNumbers[max];
allNumbers[max] ^= allNumbers[pos];
allNumbers[pos] ^= allNumbers[max--];
}
return new string(result);
} La tecnica que use,
- fue tener un arreglo predefinido de caracteres con todos los digitos,
- luego tengo una variable max que uso para llamar el metodo Random.Next(0, max),
- en cada iteracion del loop decremento esta variable,
- y cambio el numero que resulto elegido a la ultima posicion, con esto lo dejo fuera de las posibilidades para la siguiente llamada
Estos cambios me dieron una ganancia realmente minima (3 milesimas por cada 1000 llamadas), luego se me ocurrio mover la declaracion de la variable Random afuera de la funcion, para que se reusara con cada llamada a este metodo, y eso si que me dio una ganancia tremenda, llamando la funcion 10,000 veces, el metodo original me da 114ms, y el metodo nuevo 6ms, asi que ahi era donde estaba realmente el problema, lo demas es casi insignificante =o(
Seguro alguien mas puede crear una funcion mas rapida, pero yo cumpli mi objetivo =o)
salu2
- Como borrar elementos de una lista generica
-
El codigo para este articulo aplica a C# 2.0
Una tarea mas o menos comun cuando usamos una lista generica, es borrar elementos de esta, vamos a ver que alternativas tenemos:
#1 La forma definitivamente equivocada de hacerlo:
List<Person> l1 = GetList();
//*** The wrong way
foreach (Person p in l1) {
if (p.Age > 30)
l1.Remove(p);
}
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Este codigo nos dara una excepcion InvalidOperationException: "Collection was modified; enumeration operation may not execute."
#2 Funciona mas o menos (y nos permite ejecutar una accion en cada elemento que vamos a borrar)
List<int> ints = new List<int>();
ints.Add(1);
ints.Add(2);
ints.Add(3);
ints.Add(4);
ints.Add(5);
ints.Add(6);
ints.ForEach(delegate(int i) {
if ((i % 2) == 0) {
Console.WriteLine("removing"+i.ToString());
ints.Remove(i);
}
});
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Si corres este codigo funcionara perfectamente, pero la verdad es que tiene un problema grande, si agregaras los numeros pares primero, verias que no los borra todos, y no te da una excepcion ni nada, simplemente se sale del foreach y continua; asi que este metodo funciona, pero solo en condiciones especiales, lo cual lo hace codigo peligroso
#3 La forma correcta: recorremos la coleccion hacia atras y borramos elementos cuando necesitamosint x = ints2.Count;
while (--x>=0) {
if (ints2[x] < 4)
ints2.RemoveAt(x);
}
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
#4 Una mejor manera: La lista generica trae un metodo ya incluido que nos sirve para borrar multiples elementos
ints2.RemoveAll(delegate(int i) {
return i <4;
});.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
#5 Pero que pasa si quiero ejecutar una accion en cada elemento que se borre?
ints2.RemoveAll(delegate(int i) {
if (i < 4) {
//*** Perform action here
Console.WriteLine("removing :" + i.ToString());
return true;
}
else
return false;
});
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Si el elemento fuera una clase, podrias mandar llamar uno de sus metodos antes de borrarlo (por ejemplo una llamada a la base de datos)
Mas adelante escribire en detalle porque exactamente las alternativas #1 y #2 no funcionan
salu2
- Como obtener todos los campos privados de otra clase
-
Hace casi 2 meses escribi unos articulos acerca del uso de refleccion, especificamente sobre como ejecutar metodos privados, alguien dejo una pregunta sobre como podria obtener todos los campos privados de una clase, apenas hoy me di tiempo para contestar aqui mismo en el blog; primero vamos a crear una clase de prueba
class TestClass {
private int prop1;
public int Prop1 {
get { return prop1; }
set { prop1 = value; }
}
private string prop2;
public string Prop2 {
get { return prop2; }
set { prop2 = value; }
}
private bool prop3;
public bool Prop3 {
get { return prop3; }
set { prop3 = value; }
}
public bool field4;
public TestClass() {
prop1 = 10;
prop2 = "20";
prop3 = false;
field4 = true;
}
}
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
luego creamos una instancia de esta clase, y utilizamos el metodo GetFields para obtener la lista de campos, pasando como parametros que queremos los campos privados que pertenezcan a una instancia (que no sean estaticos), una vez que tenemos la lista podemos hacer lo que queramos, en este caso imprimo el tipo del campo y el valor de este
TestClass test = new TestClass();
FieldInfo[] fields = test.GetType().GetFields(BindingFlags.NonPublic BindingFlags.Instance);
foreach (FieldInfo f in fields)
Console.WriteLine(string.Format("type:{0} \t value:{1}", f.FieldType.ToString(), f.GetValue(test)));
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
listo, eso es todo. Ahora solo para hacerlo un poquito mas interesante me puse a crear una funcion generica para realizar esta tarea y puede reutilizarse con cualquier otra clase:
static void PrintPrivateFields<T>(T theInstance) where T:class {
Type t = theInstance.GetType();
FieldInfo[] fields = t.GetFields(BindingFlags.NonPublic BindingFlags.Instance);
foreach (FieldInfo f in fields)
Console.WriteLine(string.Format("type:{0} \t value:{1}", f.FieldType.ToString(), f.GetValue(theInstance)));
}
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
para usarla simplemente creamos la instancia de la clase, y pasamos esta instancia a nuestra funcion:
TestClass test = new TestClass();
PrintPrivateFields(test);
noten que no necesito pasarle el tipo generico asi
PrintPrivateFields<TestClass>(test);
sino que el compilador es inteligente y puede derivar el tipo generico.
Espero les sea util, el codigo completo lo encuentran aqui, salu2