C# fixed length på string

Hur menar du då? Ett String-objekt i .net är icke modifierbart när det väl är satt. Dock kan du ju alltid låta en strängvariabel referera till ett nyskapat String-objekt.
Alternativet är väl annars att använda en char array, vilket bör se ut ungefär så här:

char[] array=new char[4]; // 3 tecken + plats för en null-character

Detta är java-kod, men bör faktiskt funkar mer eller mindre rakt av.

såg att det fanns någon i VB som såg ut så här:

   <VBFixedString(7)> Public strCustCustID As String

men efter jag läste lite noggrannare på google så verkade inte sätta strängen till en viss längd utan det var mer ett regelverk för vissa IO-funktioner

Varför inte skapa en egen stringklass där det kastas exception om värdet är mer eller mindre.

MyStringObject obj = new StringObject(value, MaxLenght, MinLength);
MyStringObject.Value = "strängen";

Undrar hur man gör som stringobjektet och kan sätta object str = "strängen";
Är detta något kompilatorn tar hand om? Hade varit coolt att veta ^^. Antar att den förvandlar = "" till = new String("strängen")

/red Glöm det

Nickemannen skrev:

Undrar hur man gör som stringobjektet och kan sätta object str = "strängen";
Är detta något kompilatorn tar hand om? Hade varit coolt att veta ^^. Antar att den förvandlar = "" till = new String("strängen")

class Foo
{
	private string str;

	public Foo(string s)
	{
		str = s;
	}

	public static implicit operator Foo(string s)
	{
		return new Foo(s);
	}

	public override string ToString()
	{
		return str;
	}
}

Foo f = "Bar";
Console.writeline(f);

	public static implicit operator Foo(string s)
	{
		return new Foo(s);
	}

Det coola i kråksången är att man helt plötsligt kan göra egna variabler som kan ta emot flera olika typer av variabler. Säg att du vill att man skall kunna sätta Foo = 10; så behöver man bara skriva följande:

	public static implicit operator Foo(Int32 s)
	{
		return new Foo(s.ToString());
	}

Någon nytta med detta då?

Jag uttnytjade det i min ORMapper för hantering av Identifiers. För ibland så vill jag ha Guid som identifierar i databasen och ibland så vill jag ha en long (som sätts av databasen). Då kan jag i min kod skriva:

Identifier id = 10;
eller
Identifier id = Guid.NewGuid()

Vilket gör att det blir enkelt för mig att byta mella olika typer av identifiers i min databas, samt att jag har ett specifikt objekt som jag har som identifier, så jag kan göra lite mer saker i detta objekt om jag behöver...

- M

Tackar så mycket, ska se hur jag använde den koden.
går det även att göra

Foo f = "test";
Foo b = " mera test";
str s = f + b;

räcker det med att deklarera metoden ToString() eller måste man göra något annat för att ovanstående kod ska fungera?

Så, nu har jag gjort en liten klass jag kallade XString som ska göra lite formateringar.
Har inte sysslat så mycket med C# den senaste tiden så jag vet inte om jag har missar några viktiga saker.

För den som vill kolla på koden och kanske få några tips så kommer den här.
Man kan bestämma hur lång strängen ska vara, är den för kort fylls det på med mellanrum.
Man kan även bestämma om den ska vara vänster-, höger- eller mitten-justerad.
Har jag gjort några klassiska nybörjarmisstag när jag gjort min klass?

Har inte hunnit skriva några kommentarer för koden än.

	public class XString
	{
		public enum Alignment : int
		{
			Left,
			Center,
			Right
		}

		private string sStr;
		private int iLength;
		private Alignment align;

		public XString(string sStr) : this(sStr, 0, XString.Alignment.Left)
		{
		}
		
		public XString(string sStr, int iLength) : this(sStr, iLength, XString.Alignment.Left)
		{
		}

		public XString(string sStr, int iLength, Alignment align)
		{
			this.String = sStr;
			this.Length = iLength;
			this.Align = align;
		}

		public string String
		{
			get
			{
				return sStr;
			}
			set
			{
				sStr = (string)value;
			}
		}

		public int Length
		{
			get
			{
				return this.iLength;
			}
			set
			{
				this.iLength = (int)value;
			}
		}

		public Alignment Align
		{
			get
			{
				return this.align;
			}
			set
			{
				this.align = (Alignment)value;
			}
		}

		public static implicit operator XString(string s)
		{
			return new XString(s);
		}
		

		public override string ToString()
		{
			string sRet = "";
			
			switch(Align)
			{
				case Alignment.Left:
				{
					sRet = sStr.PadRight(iLength);
					int iStrLength = sRet.Length;

					if(iLength > 0 && iStrLength > iLength)
					{
						sRet = sRet.Substring(0, iLength);
					}

					break;
				}
				case Alignment.Center:
				{
					int iFirstHalf = (int)Math.Ceiling(((double)(iLength - sStr.Length)) / 2) + sStr.Length;

					sRet = sStr.PadRight(iFirstHalf);
					sRet = sRet.PadLeft(iLength);

					int iStrLength = sRet.Length;
					
					if(iLength > 0 && iStrLength > iLength)
					{
						int iRest = iStrLength - iLength;
						
						if(iRest % 2 == 1)
						{
							// Odd, remove one character from right.
							iRest--;
							sRet = sRet.Substring(0, iStrLength - 1);
						}

						iRest = iRest / 2;
						sRet = sRet.Substring(iRest, iLength);
					}

					break;
				}
				case Alignment.Right:
				{
					sRet = sStr.PadLeft(iLength);

					int iStrLength = sRet.Length;
					
					if(iLength > 0 && iStrLength > iLength)
					{
						sRet = sRet.Substring(iStrLength - iLength);
					}
					
					break;
				}
			}

			return sRet;
		}
	}