Stimmt nicht ganz 🙂.

Erstelle dynamisch die gleichen Controls mit (WICHTIG) den selben IDs in Page_Load aber ohne Daten. Nach Page_Load werden die die Daten aus dem ViewState (im falle eines Postbacks) wieder den entspechenden Controls zu gewiesen.

So muss man die Controls nur einmal befüllen.

Tilton

Hallo,

sorry, ich muss den Thread noch mal raus holen.

Ich würde gerne auch eine solche Funktionalität einbauen. Soweit auch alles kein Prob.

Nur wo bzw. wie muss ich denn dann die Java-Script Funktion aufrufen?

MfG

Tilton

PS: Meine Java-Script Kenntnisse sind nicht so dolle.

Mit jQuery kannst Du allem einen Event hinzufügen, auch einer Zelle.

Wie funzt das im Detail? Ich meine wie bekommt die currentCell ("var currentCell = $(this);")? Oder anders: wie kann man dann hinterher die Celle von einer andern unterscheiden, wenn ein td-Tag kein id-Attribut hat?

MfG

Tilton

Hallo,

die Erlösung findest du im Namespace "System.Configuration". Und der MSDN :rtfm:. =)

MfG

TiltonJH

EDIT bzw: "System.Web.Configuration" & "System.Net.Configuration"

Hallo,

na anders wird es nicht werden. Du wirst um einen Postback auszlösen einen Button, einen ImageButton oder Link nehmen müssen.

einer Celle (<td></td>) kann man diese Funktionalität nicht mit geben.

Oder eben per JavaScript und OnMouseClick o.ä. wobei man das auch wieder keiner Celle zu weisen kann (soweit ich weis).

Ergo: zb einen Link jede Celle, und in den Link den egl. Cellen-Inhalt.

Hallo Abt,

hättes du meinen und den post von Grumbler85 richtig gelesen, wäre dir aufgefallen das wir das Wort "AUFhalten" benutzt haben und nicht "ABhalten" ergo, kann überhaupt nicht einschätzen in wie weit ich kritikfähig bin oder eben nicht.

Damits deutlicher wird:

Nein, ich lasse mich natürlich nicht von der Tatsache aufhalten, dass HtmlEncode ä, ö, ü usw encodiert. Nur finde ich es nicht sonderlich clever, wenn das dann gerenderte HTML-Dokument eh UTF8 kodiert ist. ä, ö, ü usw sind Bestandteil von UTF8 und müssten somit nicht (zb. "ä" == "ä") kodiert werden. Spinnt man dies Szenario weiter, würden (ich habs noch nicht probiert) auch kyrillische oder chinesische Schriftzeichen so umkodiert werden. Und somit wäre die generelle Codierung auf UTF8 eigentlich zwecklos.

ToolTips & HtmlEncode

Im vorliegendem Beispiel sieht es folgendermaßen aus:
Doch auch in ToolTip werden Kodierte Umlaute vom Browser richtig dargestellt. Aber es ist zu beachten um welches Control und welche Eigenschaft es ich handelt, weil es sonst zu einer Doppelten Encodierung kommen kann, welche den Eindruck von nicht korrekter Interpretation erweckt: Bsp: "ä" -1. Encodierung-> "ä" -2. Encodierung-> "&amp;#228;" lesen kann man dann "ä" anstelle von dem erwartetem "ä", ist aber auch nicht anders zu erwarten.

HtmlEncode & Unicode
Ja, natürtlich gibt HtmlEncode Unicode zurück. Ein System.String Objekt ist immer Unicode, dass sagt aber doch nur wie die binäre Repräsentation eines Char Objektes ist und nicht welche Chars enthalten sind.
Das einzige wo das mal eine Rolle spielt ist für den HtmlWriter, welcher die Seite rendert. Denn der muss jetzt aus dem allgemeinen Unicode, UTF8 machen. (Wobei UTF8 ist eine Form von Unicode ist aber eben nicht die, die von System.String Objekten genutzt wird.)

Was sollte das HtmlEncode nun eigentlich nur machen?
Alle Zeichen eines Stings in eine HTML -"Escapete" Form überführen, die ein Browser als Steuerzeichen interpretieren könnte oder in der für die Seite gewählte Text-Encodierung nicht vorhanden ist.
Daher die Frage: Gibt es sowas und wenn ja wo?

Bis jetzt sieht es wirklich so aus als wenn ich das selber machen müsste. 😜 Finde ich blöd.

Ein Label rendert aber auch einen

<span></span>

, das will ich aber nich.

Aufhalten lass ich mich davon nich, nur eure Meinungen hätten mich mal interessiert.

MfG

Tilton

Hallo,

um immer wieder benötigte Kombinationen von ASP-Controls nich immer wieder zusammenbauen zu müssen habe ich mir eigene UserControls gebaut. Soweit so gut, alles kein Problem.

Ist oft sowas von der Art:

<asp:Literal runat="server" ID="caption" />
<asp:DropDownList runat="server" ID="dropDownList" />
<asp:RequiredFieldValidator runat="server" ID="requiredFieldValidator" ControlToValidate="dropDownList" ErrorMessage="<%$ Resources:Lang,ErrorEntryRequired %>" />

Wenn ich die Bezeichnung, also das Literal mit Namen aus der Datenbank füttere, welche der User selber definieren kann. Genau hier is die Möglichkeit von HtmlJnjection gegeben.

Einfache Lösung:

public string Caption
{
	get { return this.dropDownList.ToolTip; }
	set
	{
		var text = this.Server.HtmlEncode(value);
		this.caption.Text = string.Concat(text, ": ");
		this.dropDownList.ToolTip = text;
	}
}

Frage:

Wie kann ich dem HtmlEncode einreden UTF8 Zeichen in Ruhe zulassen? ZB. muss der mir die ä, ö, usw. nicht mit encodieren. Oder sollte man das trozdem? Nur umsicherzugehn? 🤔

MfG

TiltonJH

PS: Hin und wieder is das total verzwickt, manche ASP-Controls machen selber ein HtmlEncode, ander nich. Machne wieder rum nicht bei allen Eigenschaften...

Um die Verwirrung hoffentlich aufzulösen, habe ich mal die Klassendiagramme der eigentlichen Implementierung hochgeladen.

Wie man da sehn kann wird aus Foo -> Table und aus Bar -> Column.

Das Konzept is also so ne art DB-Table aber mit .Net-Datentypen (deswegen auch kein DataTable).

Jede Spalte hat ihren eigen Datentyp. Man könnte auch einfach alles ohne generic lösen, aber dann müsste man sich irgendwie anders drum kümmern, dass jede Spalte nur mit dem jeweilig richtigen Datentyp bestückt wird.

MfG

TiltonJH

Der Fehlerteufel

Gleichzeitig aber auch alle normalen Klassen.

-> hätte sein müssen:

Gleichzeitig aber auch alle normalen Klassen erlauben.

Ich seh schon muss etwas mehr ausholen.

internal class Bar<T> : IEnumerable<T> : IBar
{
	[...]
	public void Add(T item) { [...] }
	void IBar.Add(object item)
	{
		if (item is T)
			this.Add((T)item);
		else
			throw new InvalidOperationException("wrong type.");
	}
	Type IBar.BarType { get { return typeof(T); } }
	[...]
}

public interface IBar : IEnumerable
{
	[...]
	void Add(object item);
	Type BarType { get; }
	[...]
}

public class Foo : IEnumerable<IBar>
{
	[...]
	private IList<IBar> bars = new List<IBar>();
	public void AddNewBar<T>()
	{
		this.bars.add(new Bar<T>());
	}
	public void Add(int index, object item)
	{
		this.bars[index].Add(item);
	}
	public Type[] GetBarTypes()
	{
		var array = new Type[this.bars.Count];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = this.bars[i].BarType;
		}
		return array;
	}
	[...]
}

Ich hoffe nun wird es etwas klarer.

Die Idee mit
BarStruct<T> : IBar where T : struct { }
BarClass<T> : IBar where T : class { }
is da dann schon hilfreich und könnte der Weg zu Lösung sein.

MfG

Tilton

Wäre mgl, ja. Aber mit T wird intern eine Klasse (ich nenn die jetzt mal) Bar<T> angelegt.

🤔

BarStruct<T> : IBar where T : struct { }
BarClass<T> : IBar where T : class { }

🤔

na ja ... mit dem Gedanken muss ich erst ma' bissel schwanger gehn.

Danke

Ich wollte alle NICHT-Nullable<T> Werte-Typen verbieten, sprich erzwingen das man bspw. int? nutzen muss und int nicht.

EDIT: Gleichzeitig aber auch alle normalen Klassen.

MfG

Tilton

Hallo,

na ja das ganze Konstrukt ist auch deutlich komplexer. Das Constraint hab ich mittlerweile auch schon ausgebaut.
Sinn war egl. das innerhalb der Klasse Foo Add<T>(null); schreiben kann. Hab das jetzt durch Add<T>(default(T)) ersetzt.

Die Aufgabe des Constraint war egl. eben nur vollwertige "Nullable"s überhaupt zu gelassen sind.
Ohne dieses Constraint könnte Jimmy jetzt auch Werte-Typen verwenden, was der gesammten Hilfsklasse den Sinn nimmt.

MfG

Hallo,

ich habe folgendes Problem:

public class Foo
{

	[...]

	public void Add<T>(T item)
		where T : class //damit item auch null sein kann
	{
		[...]
	}

	[...]

}

public static class Program
{
	public void Main(params string[] args)
	{
		var foo = new Foo();
		foo.Add<SomeClass>(new SomeClass());
		foo.Add<int?>(4);
		foo.Add<int?>(null);
	}
}

Nun ist Nullable<T> nun mal ein struct, kann selbst also nicht null sein.

Fehlermeldung:
The type 'int?' must be a reference type in order to use it as parameter 'T' in the generic type or method 'Foo.Add<T>(T item)'.

Mein Lösungsansatz: eine eigene Klasse nach dem Vorbild von Nullable bauen.
Irgendwie glaube ich, dass das auch nicht zum Ziel führt.

Vorschläge, eure Gedanken?

MfG

Tilton

in manchen Fällen kann man das mit new lösen - aber man sollte wirklich genau wissen, wann und wann nicht; Generics sind meist der geeignetere Weg.

ne, ja, nee...

mir geht es ja genau darum die methoden (o.ä.) nich in den subklassen bekanntgeben oder überschreiben zu müssen, sondern diese per vererbung zu erhalten.

MfG

Tilton

das geht nicht, genau für sowas sind Generics doch da. Warum willst du ohne die arbeiten?

Schade X( !
Warum weil ich zu faul bin mein ganzes ObjektModel auf eben diese Generic-Geschichte umzustellen 😄.

Und ich wird dachte das den jeweiligen Typ der SubKlasse nach unten zu geben is komisch, das könnte man doch standardmässig so vorsehn, zb über ein key-wort das ich noch nich kenne 😉 .

MfG

Tilton

@inflames2k: sorry, aber ich glaube du hast das problem nicht verstanden. die GetThis methode is der dreh und angelpunkt, und die gibt es natürlich kein prob.

@MarsStein: auch du hast nich verstanden nach was ich gefragt habe.

Ich möchte in der basisklasse eine methode, ein property, oder ein feld anlegen, welches aber nich vom typ der basisklasse ist, sondern von der jeweiligen subklasse. da (wie MarsStein richtig feststellte) eine basisklasse nicht wissen kann / sollte welche subklassen es gibt, lässt sich das prob nur über generic (s.o.) lösen

was ich suche ist nach einem weg ohne generic zu nutzen.

ein objekt (die instanz einer klasse) weis ja von welchem konkreten typ sie ist, ergo such ich etwas in der form:

public abstract class Base
{
    //...

    public derivedClass GetThis()
    {
        return this;
    }

    //...
}

public class SomeClass : Base
{
    //...
}

MfG

Tilton

Hallo,

folgende Situation:

public abstract class Base<T> where T : class
{
	//...

	public T GetThis()
	{
		return this;
	}

	//...
}

public class SomeClass : Base<SomeClass>
{
	//...
}

Kann man sowas auch ohne Generic lösen? Also das, ich in der Base class mit dem egl Typ des Objekts arbeiten kann ohne ihn per Gerneric bekannt geben zu müssen?

MfG

TiltonJH

Das Thema ist zwar als gelöst gekenzeichnet, kann mir trotzdem jemand ein vernünftigen Grund geben weshalb dies bei WebApplikationen funktioniert jedoch nicht für WebSites ?

Hallo,

die Frage ist einfach zu beantworten.

Der Projekttyp "WebSite" ist so wie er im Projektorder ist schon vollständig. Diese wird in der Regel nicht "gepublished", sondern er wird so wie er ist einfach 1:1 kopiert (mit allem drumm und drann). Binär-Code wird dann erst zur Laufzeit vom IIS erstellt. Der IIS interessiert sich nur für die Web.config. Eine Web.Relase.config o.ä. wird ignoriert. Die nötigen Transformationen werden nie gemacht.

Der Projekttyp "WebApplikationen" ist deutliche mehr als nur eine WebSite. Sie hat grundsätzlich mehr Ähnlichkeit mit einer dll. So verfügt sie über weit mehr "Methadaten". Diese werden bei beim Erstellen des Projektes ausgewertet. Was muss compiliert werden, was wird in den "Ergebnisordner" kopiert, was wird ingnoriert, was wird Teil der dll usw.

Die Transformations-Anweisungen in den Web.*.config's werden vom VS erst bei einem "publishen" ausgewertet und es schreibt eine neue transformierte Web.config für den Ergebnisordner.

Wenn man also genau hinschaut hat man 4 mitunter verschiedene Anwendungen:

1. In VS im Modus Debug starten. -> Die Debug-Build-Einstellungen für die dll und die Web.config.
2. In VS im Modus Release starten. -> Die Release-Build-Einstellungen für die dll und die Web.config.
3. In VS im Modus Debug publischen und dann mithilfe eines IIS starten. -> Die Debug-Build-Einstellungen für die dll und die Web.config + Transformationen der Web.Debug.config.
4. In VS im Modus Release publischen und dann mithilfe eines IIS starten. -> Die Release-Build-Einstellungen für die dll und die Web.config + Transformationen der Web.Release.config.

(FYI: In den Eigenschaften des Projektes kann unterem Punkt Build eingestellt werden was in welchem Modus (Debug | Relase) gemacht werden soll. Diese Einstellungen haben dann Einfluss auf die generierten "Binär-" bzw. dll-Dateien. Diese und andere Einstellungen kann man bei einer WebSite nicht machen.)

MfG

Tilton

PS: Ich würde einer WebApplication immer den Vorzug geben. WebSite's hab so einige Macken die sehr lästig werden können.

Nach ein wenig rumtesten...

Das <pre></pre>-Tag hat einen Nachteil, es erzwingt einen Zeilenumbruch vor sich.

Lösen lässt sich das ganze auch über CSS mit dem white-space-CSS-Element, welches diesen Nachteil nicht hat und man kann auch noch noch ein paar mehr Einstellungen vornehmen als mit einem reinen <pre></pre>-Tag.

<asp:TemplateField HeaderText="<%$ Resources:Lang,Message %>" ItemStyle-VerticalAlign="Top">
	<ItemTemplate>
		<asp:Label runat="server" Text='<%# Eval("Message") %>' CssClass="editor" />
	</ItemTemplate>
</asp:TemplateField>

span.editor
{ 
	white-space:pre-wrap;
}

Vielen dank.

Die Mischung machst. 8)

Den <pre></pre>-Tag kannte ich noch gar nich. Den und ein asp:Literal (innerhalb eines TemplateField) welches den Text aufnimmt sind die Lösung des ganzen.

<asp:TemplateField HeaderText="<%$ Resources:Lang,Message %>" ItemStyle-VerticalAlign="Top">
	<ItemTemplate>
		<pre><asp:Literal runat="server" Text='<%# Eval("Message") %>' /></pre>
	</ItemTemplate>
</asp:TemplateField>

MfG

Tilton

Hallo,

Eine Gruppe - Item Beziehung ist aber zwangsweise keine m:n Beziehung.

Das wird erst eine m:n wenn items auch in mehreren Gruppen sein können sollen.?

Wenn es denn unbedingt m:n sein muss funzt das bei mir ganz supi.

public GroupMap()
{
	...

	this.HasManyToMany(x => x.Items);
}

public ItemMap()
{
	...

	this.HasManyToMany(x => x.Groups);
}

EDIT:

Eine m:1:n Beziehung, da is doch nur wichtig was "1" ist.

Das Könnte zB sowas sein:

public class GroupItemConnector
{
	public ISet<Group> Groups { ... }
	public ISet<Item> Items { ... }
}

PS: Vorsichtig mit IList und ISet usw. meist wird egl nur eine ISet gebraucht. Es sei denn ein Item soll mehr fach in der selben Group sein.

MfG

Tilton

Hallo,

Kontext:
Ich möchte Text den ich aus meinen DB beziehe in einem GridView darstellen. Funzt auch alles Prima.

Problem:
Der Text hat im Original Zeilenumbrüche. Diese möchte ich natürlich auch mit darstellen.

Meine Lösung:

text.Replace(Environment.NewLine, "<br />")

Das nächte Problem:
Jetzt wird Text in der Form dargestellt:

Lorem ipsum dolor sit amet, consectetuer adipiscing elit.<br />Etiam id erat at tellus tincidunt mollis. Praesent mattis tortor eu est.<br />Donec congue sagittis arcu. Etiam viverra erat ut nulla.<br />Donec hendrerit tortor et metus. Maecenas rhoncus dapibus leo. Donec vel ipsum ut felis vestibulum varius. Mauris ipsum nisl, accumsan eget, gravida non, mattis nec, nunc. Pellentesque pellentesque erat a arcu. Nulla semper, metus ac<br />volutpat congue, ipsum felis mattis felis, sed placerat dolor velit ac urna. Nunc convallis. Donec non ligula nec nunc accumsan consequat.<br />Ut in mauris. Vestibulum vitae neque sed eros convallis molestie. Phasellus quis ligula non tortor<br />mattis mollis. Vestibulum sit amet ipsum ut ligula iaculis tincidunt.

Soll heißen ASP konvertiert löblicher weise meinen Text in eine Web-Darstellbare-Form.
Frage:
Wie schaffe ich es die "<br />" erst einzubauen nach dem die Web-Darstellbare-Form durch ist?
Oder Welche Methode ist dafür zuständig und kann die Überladen werden?

Danke.

MfG

Tilton

Hallo,

ich setzte SSL (https) auch ein mit

ASP.NET 3.5
Ajax Toolkit 3.5

als auch

ASP.NET 4
Ajax Toolkit 4

kann aber von keinen Probsberichten.

Welchen ScriptManager nehmt ihr? (ToolKit | ASP)

Für welche url ist euer Zerzifikat ausgestellt und über welche url greift ihr eure Anwendung zu?

Und was bitte ist "VDesk"?

MfG

Ich würde einen weiteren Ansatz in Betracht ziehen.

Ein richtiges Diagramm. Etwas was MS für .NET nach geliefert hat. 😁

http://weblogs.asp.net/scottgu/archive/2008/11/24/new-asp-net-charting-control-lt-asp-chart-runat-quot-server-quot-gt.aspx

Und da Bilder mehr sagen als Tausend Worte noch ein Bildchen im Anhang (weitere gibs auch auf der Seite).

Das ganze funzt auch im VS2010. D.h. installiert hab die Control-Erweiterung nicht, aber nützt eh nur dem Desinger, und denn mag ich eh nich 8)

MfG

Tilton

Hallo,

ich bin gerade dabei Bäume mit Benutzer(Gruppen-)rechten zu versehn. Die eigentliche Implementierung ist nich das Prob. Aber ich frage mich ob ihr sachdienliche Hinweise, Vorschläge oder Literatur dazu habt? Besonders geht es mir darum das Ganze recht performant zu gestalten.
Gespeichert oder geladen wird alles mit NHibernate & lazy-loading.

Zu den Fakten:*es gibt Benutzer und Gruppen; n-n Beziehung

*die Rechte sollen dann zwischen den Gruppen und den Bäumen exsitieren, wobei die Gruppe nicht wissen soll/darf, dass es überhaupt Rechte oder gar Bäume gibt.

*es soll die Rechte: Lesen, Bearbeiten und evtl. Löschen geben (ich schwanke noch, Löschen als Teil von Bearbeiten anzusehen, da beides gleich gefährlich ist (IMHO))
Wobei nicht der Baum als solches Bearbeitet/Gelöscht wird, sondern spezielle Elemente die sich zusätzlich an jeden Knoten hängen können

*Benutzer haben Rechte auf einen Konten des Baums, diese Rechte werde, nach unten im Baum weiter "vererben"|"gereicht" und gradlinig nach oben bis zum Root nur lesen des Baumes (quasi als Pfad) ermöglichen soll.

*Teile des Baums die man nicht mindestens lesen kann, sind auch nicht anzuzeigen (später in der GUI)

ich hoffe ich habe alle... 🤔

Danke schon mal für eure Anregungen/Ideen!

MfG

Tilton

Mein Lösung:

Aber immer noch etwas schmutzig, da im C#-Code genau eingestellt werden muss wie viele Controls das ModalPopupPanel selber hat (siehe "const int controlCount = 5;").

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ModalPopupPanel.ascx.cs" Inherits="WebServer.Utilities.ModalPopupPanel" %>
<div class="divModalBackground">
</div>
<asp:AlwaysVisibleControlExtender runat="server" TargetControlID="panelModalPopup" HorizontalSide="Center" VerticalSide="Middle" />
<asp:Panel runat="server" ID="panelModalPopup" CssClass="divModalPopup" />

using System.Web.UI;

namespace WebServer.Utilities
{
	[PersistChildren(true)]
	[ParseChildren(false)]
	public partial class ModalPopupPanel : UserControl
	{
		protected void Page_Init()
		{
			const int controlCount = 5;
			while (this.Controls.Count > controlCount)
			{
				this.panelModalPopup.Controls.Add(this.Controls[controlCount]);
			}
		}

	}
}

Jup, so hab ich das auch gemacht.

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ModalPopupPanel.ascx.cs" Inherits="WebServer.Utilities.ModalPopupPanel" %>
<div class="divModalBackground">
</div>
<asp:AlwaysVisibleControlExtender runat="server" TargetControlID="panelModalPopup" HorizontalSide="Center" VerticalSide="Middle" />
<asp:Panel runat="server" ID="panelModalPopup" CssClass="divModalPopup" />

using System;
using System.Web.UI;

namespace WebServer.Utilities
{
	public partial class ModalPopupPanel : UserControl
	{
		protected void Page_Load(object sender, EventArgs e)
		{
		}

		[TemplateContainer((typeof(UserControl)))]
		[PersistenceMode(PersistenceMode.InnerProperty)]
		public ITemplate PanelControls
		{
			get;
			set;
		}

		void Page_Init()
		{
			if (this.PanelControls != null)
			{
				this.PanelControls.InstantiateIn(this.panelModalPopup);
			}
		}

	}
}

Böld is die stelle mit

[TemplateContainer((typeof(UserControl)))]

Das hier ein Typ angegeben werden muss. UserControl funzt auch mit normalen Control.
zb:

<uc:ModalPopupPanel runat="server" ID="modalPopupPanelTest" Visible="false" >
	<PanelControls>
		<asp:Button runat="server" ID="buttonWech" Text="wech..." OnClick="buttonWech_Click" />
	</PanelControls>
</uc:ModalPopupPanel>

Aber was auf diese weise nicht mehr geht is, dass ich die Child-Controls direkt aus der Page ansprechen kann. In meiner Lösung geht das.

Deswegen werde ich woll erstmal bei meiner bleiben. Schön wäre es zu wissen mit wechler Methode die Child-Controls zur laufzeit in das UserControl geschoben werden. Da könnte man die dann einfach in das Panel umleiten.
Dein Mein UserControl soll sich von außen wie ein normales Panel benehmen.

MfG

Tilton

Ich habs gelöst bekommen. Nicht unbedingt sehr elegant, aber es funzt. Wenn jmd verbessungspotensial sieht immer her damit.

Ich weis das mein ModalPopupPanel 6 Einträge in Controls hat, jedes weitere bekommt es von der Page. Und die verschiebe ich einfach in mein Panel (also da wo die hin sollen). 😁

Mir wäre es lieber, ich könnte gleich alle Children in das Panel umlenken. Wenn ich nur wüsste wie.

Meine Code:

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ModalPopupPanel.ascx.cs" Inherits="WebServer.Utilities.ModalPopupPanel" %>
<div class="divModalBackground">
</div>
<asp:AlwaysVisibleControlExtender runat="server" TargetControlID="panelModalPopup" HorizontalSide="Center" VerticalSide="Middle" />
<asp:Panel runat="server" ID="panelModalPopup" CssClass="divModalPopup" />

using System;
using System.Web.UI;

namespace WebServer.Utilities
{
	[PersistChildren(true)]
	[ParseChildren(false)]
	public partial class ModalPopupPanel : UserControl
	{
		protected void Page_Load(object sender, EventArgs e)
		{
		}

		void Page_Init()
		{
			const int controlCount = 6;
			if (this.Controls.Count > controlCount)
			{
				for (int i = controlCount; i < this.Controls.Count;)
				{
					this.panelModalPopup.Controls.Add(this.Controls[i]);
					this.Controls.RemoveAt(i);
				}
			}
		}

	}
}

EDIT:

@MarsStein, das werde ich mir auch gleich noch mal aunschaun. thx

MfG

TiltonJH

So richtig Schlauch werde ich aus dem Beispiel nicht. Dort wird eine eigene Klasse im page_init erstellt und in den placeholder geschoben.

Ich möchte aber das auf der Page (.aspx) einem bestimmten UserControl (.ascx) Chlidren zu gewiesen werden können, die dann an ein vorherbestimmten Stelle innerhalb des UserControls erstellt werden. Das Beispielt hilft da nicht wirklich. ich weis das die Children auch dem UserControl.Controls property zu gewiesen werden. aber angezeigt werden sie nirgens und schon gar nich wo ich die gerne hätte. 🙁

MfG

Tilton

Ich würde gerne etwas in der art zum laufen bringen

irgendwo in der Page:

<uc:ModalPopupPanel runat="server" ID="test" >
	<asp:Label ID="TestLabel" text="TestLabelText" runat="server" />
	<asp:Button Text="text" runat="server" />
</uc:ModalPopupPanel>

das uc (UserControl)
code behind:

[PersistChildren(true)]
[ParseChildren(false)]
public partial class ModalPopupPanel : UserControl
{
	protected void Page_Load(object sender, EventArgs e)
	{
	}
}

asp.net

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ModalPopupPanel.ascx.cs" Inherits="WebServer.Utilities.ModalPopupPanel" %>
<div class="divModalBackground">
</div>
<asp:AlwaysVisibleControlExtender runat="server" TargetControlID="panelModalPopup" HorizontalSide="Center" VerticalSide="Middle" />
<asp:Panel runat="server" ID="panelModalPopup" CssClass="divModalPopup">XXX</asp:Panel>

Die Controls in der Page sollen an der Stelle wo die XXX im asp des UC stehen auftauchen.

1. Geht das überhaupt?
2. Wenn ja wie?

Bemerkung;

der code als solches funzt, nur eben die child controls (in der page spezifiziert) werden nich angezeigt.

MfG

Tilton

Hallo,

ich habe oben eine nochmal überarbeitete Version rein gestellt. Leerzeichen am Anfang werden nun übersprungen, auch die String.StartsWith() habe ich durch performanteren Code ersetzt.

Strings, wie beispielsweise: "0x01 23 45 67 89 ab cd ef AB CD EF", werden aber immer noch nicht übersetzt. Hier hilft ein:

Hexadecimal.ToBytes (Hexadecimal.ValidateHexString ("0x01  23  45  67  89  ab  cd  ef  AB  CD  EF"))

aber stark weiter 8).

MfG

Tilton

Hallo,

ja eine ähnliche Funktion besitzt das .Net Framework schon. Aber eben nur ähnlich.

Einen Int32 oder Int64 in hex wandeln und wieder zurück nützt ja nur für 1 bis 8 Byte lange HexStrings etwas. Und selbst dann ist das Ergebnis eben ein int und kein Byte[].

Es gibt keine Funktion mit der man von einen beliebig langen HexString in Byte[] wandeln kann. Auch gibt es keine mir bekannte Möglichkeit ein beliebig großes Byte[] in HexString wandeln könnte. Deswegen also hier diese Klasse.

MfG

TiltonJH

Hallo,

aus aktuellem Anlass möchte ich meinen Text File Encoding Converter vorstellen. Es ist ein Konsolen-Programm um Text-Dateien von einer Kodierungen in eine andere zu ändern.

Hier mal ein Auszug aus der Hilfe:

[pre]
Text File Encoding Converter 1.1.1.7
------------------------------------

License:
--------
This work is licensed under a Creative Commons Attribution-Share Alike 3.0
Unported License.
See <http://creativecommons.org/licenses/by-sa/3.0/> for more information.

Description:
------------
Convertes text file encodings from one codepage to another.



Syntax:
-------
converter <file> [<output file>] [-from:<CodePage|Name>] [-to:<CodePage|Name>] [-overwrite] 
          | [-help]


Semantic:
---------
       <file>   - A file to convert.

<output file>   - <file> will be converted and saved to <output file>.
                  If not specified a temporay file is used, which will replace <file>.

     from | f   - The encoding used to read.  default: 1252

       to | t   - The encoding used to write. default: 850

overwrite | o   - Overwrite without prompt.

     help | ?   - Shows this help.


Example:
--------
converter textFile.txt newTextFile.txt -from:utf-8 -to:437
[/pre]

Quell-Code gib's auf Anfrage.

MfG

TiltonJH

Hallo herbivore,

die problematik des encoding ist mir schon bekannt, aber mit 850 hast wohl sicher recht. 😁
es war eigentlich mehr die frage, ob das so gewollt war/ist. 😉

ein solches c#-programm gibt es schon, ich werde das wohl gleich hier mal als projekt veröffentlichen. 😁

hab da aber noch was anderes: in der regexlab.html ist auf zeile 123 ein fehler. da steht: "&lt;name>" es sollte aber wohl "\k<name>" heißen. 🤔

MfG

TiltonJH

hallo,

ich möchte mich hier meinen Vorrednern anschließen!

Aber eine frage hätte ich dann doch noch gerne, als dann mal geschaut hab wie du das geschrieben hast stelle sich mir die frage: warum is die quellcode-datei in der dos codepage (437)? 🤔 bei mir werden die umlaute alle falsch dargestellt.

MfG

@zommi
danke für deine antwort, aber von angst kann hier keine rede sein, mir schon klar das schloss und riegel nicht helfen wenn der einbrecher schon im haus is und der beste tresor nix taugt wenn er immer offen steht usw... 😉

ich wollte nur mal fragen ob ich vlt was übersehn habe und das hab ich offensichtlich nicht, schön zu wissen. 😃

das bringt mich aber zurück zu den SecureString. welchen nutzen haben dann diese Objecte? bzw wie verwendet man die wenn man an den inhalt eh nich wieder ran kommt?

MfG
TiltonJH

Hallöle,

jetzt hab ich mir den SecureString mal angeschaut. Aber so richtig schlau werde ich nicht daraus.

1. Warum muss man jedes char einzeln und keinen ganzen string auf einmal rein packen? das jetzt nich weiter ein prob, fix ne foreach schleife geschrieben und fertig, aber komisch is das trotzdem.

2. Wie bekomme ich die chars, den ganzen string da wieder raus wenn ich den brauche? die ToString() Methode is nich überladen und bringt nur "System.Security.SecureString" von der Object.ToString() Methode. Jede andere Methode oder Eigenschaft scheint hier auch keine Hilfe zu sein.

3. was mache ich wenn ich zahlen oder allgemein andere Objekte verschlüsselt
   ablegen will? (im RAM)

4. wenn ich den SecureString irgendwann mal als einen nativen string hatte is der doch dann auch zwecks der String-Optimierung immer noch im RAM?

5. selbst wenn der GC dann mal aufräumen sollte, heißt das ja noch lange nich das die stelle mit dem string im RAM auch ihre binären werte verloren hat, ähnlich wie das bei Festplatten und Dateien der Fall ist?

6. zu 5. kann man dem GC sagen ersoll den freien Bereich im RAM (welcher noch zum assembly gehört mit binären 0 flushen oder sowas? so das zumindest wenn das Prog beendet wurde der RAM sauber ist?

Für mich bedeutet das immer das man da egl nich wirklich was machen kann. Ich glaube aber mal gelesen zu haben das es ab Vista wohl einen Dienst oder ähnlich gibt der den Zugriff auf den RAM welcher nicht selbst belegt oder von andern Prozessen verwendet wird unterbinden soll. Kann das jmd bestätigen??

MfG

TiltonJH

Hallo,

Das mit der Überprüfung des Strings auf Gültigkeit geht mit RegEx sehr einfach

Das mag sein, aber das Parsing und das Ausführen der RegEx braucht ne ganze Ecke mehr Rechenschritte als meine Implementierung.
D.h. RegEx ist einfach zu implementieren bzw. zu nutzen (bringt das Framework schon mit), aber aus Sicht der Performance ist es aufwendiger.

  
...  
 text = text.Replace("0x","");  
...  
  

Ein Replace ist auch wieder aufwendiger als ein einfaches Überspringen der ersten 2 Zeichen. Ein Replace erzeugt einen neuen String (inkl. Speicherreservierung, Zeichen kopieren usw.). Von der Tasache das bei Replace der gesammte String mindestens einmal durchsucht werden muss, mal ganz abgesehn.

  
...  
if ((text.Length % 2) != 0)  
...  
  

Der Modulo wird intern mit Hilfe von Division errechnet (die genaue Formel hab ich grad nich im Kopf mal, wer 's wissen sollte mal Google/Wiki befragen 😉 ). Division ist eine sehr aufwendige Rechenoperation.
Ein simples Logisches & hingegen sehr sehr viel schneller.

  
if (text.Substring(0, 2).ToLower().StartsWith("0x"))  
    text = text.Substring(2);  
  

Alleine in "text.Substring(0, 2).ToLower()" werden 2 neue Strings erstellt.

Auf derlei Sachen wollte ich eben explizit verzichten.

Das Beachten/Filtern von Leerzeichen, ist jedoch eine Idee die ich mit einbauen könnte. Werde ich mir mal durch den Kopf gehen lassen.

Bei "StartsWith("0x")" kann ich mir vor stellen das es auch noch ein paar Optimierungen geben könnte, da werde ich mir mal anschaun, wie das dass Framework intern gelöst hat und ob was man besser machen könnte.

MfG

TiltonJH

Hi,
ein wirklich sehr guter Artikel. Ich glaub nun versteh ich Regex auch endlich mal. 😁

Einen Verbessungsvorschlag hätte ich dann, aber doch noch.

Die "breaks;" in der switch-Anweisung weglassen. Da vor dehnen ein "return [...];" kommt werden die eh nich benötig. Ferner sollten die Compiler-Warnungen erzeugen.

-->

public string ReplaceMethode(Match m)
{
	switch (m.Value)
	{
		case "ae":
			return "ä";
		case "oe":
			return "ö";
		case "ue":
			return "ü";
		case "Ae":
			return "Ä";
		case "Oe":
			return "Ö";
		case "Ue":
			return "Ü";
		default:
			return "";
	}
}

MfG

TiltonJH

hab mal neueren code rein gestellt. 8)

-> stark überarbeitet & kommentare eingefügt

tilton

Grüße.

Keine Ahnung ob das Prob noch besteht, aber ich gebe trozdem mal meinen Senf dazu. 😁

Wenn ich mir deine Kompriemierung anschaue dann fällt mir auf das du den "compressedzipStream" nicht ge"Flush"t bzw. geschlossen wurde. So wie das verstehe schreibt der GZipStream aber erst beim schliesen den letzten Block voll (Könnten auch MetaInfos sein, der schreibt halt noch was rein 😉).

Ich hab auch ne ganze Weile mit rumspielen müssen, bis das was rein ging auch wieder raus kam.

Schau dir mal meine C#-Snippets -> GZip Helper-Klasse an bzw. versuchs mal damit. Vlt. kommst du damit weiter.

MfG

TiltonJH

Beschreibung:

Da ich im Forum immer mal wieder auf Fragen und Probleme bezüglich GZip stoße und mich das selber mal beschäftigt hat, werde ich hier mal meine GZIP Klasse als Lösung rein stellen.

Im Prinzip macht sie den GZipStream mit statischen (helper-)Methoden verfügbar und somit leichter ver-/anwendbar.

using System;
using System.IO;
using System.IO.Compression;

namespace Tools.Packer.GZIP
{
	/// <summary>
	/// Provides methods used to compress and decompress using a System.IO.Compression.GZipStream.
	/// </summary>
	public static class GZIP
	{
		private const int bufferSize = 1 << 12; // Pow(2, 12) == 4096
		private const string canNotRead = "Can not read.";
		private const string canNotWrite = "Can not write.";
		private const string canNotSeek = "Can not seek.";

		/// <summary>
		/// Compresses a System.Byte[], using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="bytes">A uncompressed System.Byte[].</param>
		/// <returns>A compressed System.Byte[].</returns>
		/// <exception cref="System.ArgumentNullException">bytes is null.</exception>
		public static byte[] Compress(byte[] bytes)
		{
			if (bytes == null)
				throw new ArgumentNullException("bytes");

			using (var uncompressed = new MemoryStream(bytes))
			using (var compressed = new MemoryStream())
			{
				Compress(uncompressed, compressed);
				return compressed.ToArray();
			}
		}
		/// <summary>
		/// Compresses a System.IO.Stream, using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="stream">A uncompressed System.IO.Stream to compress.</param>
		/// <exception cref="System.ArgumentNullException">stream is null.</exception>
		/// <exception cref="System.ArgumentException">Can not read from stream.</exception>
		/// <exception cref="System.ArgumentException">Can not write to stream.</exception>
		/// <exception cref="System.ArgumentException">Can not seek in stream.</exception>
		public static void Compress(Stream stream)
		{
			if (stream == null)
				throw new ArgumentNullException("stream");
			if (!stream.CanRead)
				throw new ArgumentException(canNotRead, "stream");
			if (!stream.CanWrite)
				throw new ArgumentException(canNotWrite, "stream");
			if (!stream.CanSeek)
				throw new ArgumentException(canNotSeek, "stream");

			using (var ms = new MemoryStream())
			{
				stream.Position = 0;
				Compress(stream, ms);
				ms.Position = 0;
				stream.Position = 0;
				stream.SetLength(ms.Length);
				byte[] buffer = new byte[bufferSize];
				while (true)
				{
					int read = ms.Read(buffer, 0, buffer.Length);
					if (read == 0)
						break;
					stream.Write(buffer, 0, read);
				}
			}
			stream.Flush();
		}
		/// <summary>
		/// Compresses a System.IO.Stream, using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="uncompressed">A System.IO.Stream containing uncompressed data.</param>
		/// <param name="compressed">A System.IO.Stream to write the compressed data into.</param>
		/// <exception cref="System.ArgumentNullException">uncompressed is null.</exception>
		/// <exception cref="System.ArgumentNullException">compressed is null.</exception>
		/// <exception cref="System.ArgumentException">Can not read from uncompressed.</exception>
		/// <exception cref="System.ArgumentException">Can not write to compressed.</exception>
		public static void Compress(Stream uncompressed, Stream compressed)
		{
			if (uncompressed == null)
				throw new ArgumentNullException("uncompressed");
			if (compressed == null)
				throw new ArgumentNullException("compressed");
			if (!uncompressed.CanRead)
				throw new ArgumentException(canNotRead, "uncompressed");
			if (!compressed.CanWrite)
				throw new ArgumentException(canNotWrite, "compressed");

			using (var gzip = new GZipStream(compressed, CompressionMode.Compress, true))
			{
				byte[] buffer = new byte[bufferSize];
				while (true)
				{
					int read = uncompressed.Read(buffer, 0, buffer.Length);
					if (read == 0)
						break;
					gzip.Write(buffer, 0, read);
				}
				gzip.Flush();
			}
		}

		/// <summary>
		/// Decompresses a System.Byte[], using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="bytes">A compressed System.Byte[].</param>
		/// <returns>A uncompressed System.Byte[].</returns>
		/// <exception cref="System.ArgumentNullException">bytes is null.</exception>
		public static byte[] Decompress(byte[] bytes)
		{
			if (bytes == null)
				throw new ArgumentNullException("bytes");

			using (var compressed = new MemoryStream(bytes))
			using (var uncompressed = new MemoryStream())
			{
				Decompress(compressed, uncompressed);
				return uncompressed.ToArray();
			}
		}
		/// <summary>
		/// Decompresses a System.IO.Stream, using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="stream">A compressed System.IO.Stream to decompress.</param>
		/// <exception cref="System.ArgumentNullException">stream is null.</exception>
		/// <exception cref="System.ArgumentException">Can not read from stream.</exception>
		/// <exception cref="System.ArgumentException">Can not write to stream.</exception>
		/// <exception cref="System.ArgumentException">Can not seek in stream.</exception>
		public static void Decompress(Stream stream)
		{
			if (stream == null)
				throw new ArgumentNullException("stream");
			if (!stream.CanRead)
				throw new ArgumentException(canNotRead, "stream");
			if (!stream.CanWrite)
				throw new ArgumentException(canNotWrite, "stream");
			if (!stream.CanSeek)
				throw new ArgumentException(canNotSeek, "stream");

			using (var ms = new MemoryStream())
			{
				stream.Position = 0;
				Decompress(stream, ms);
				ms.Position = 0;
				stream.Position = 0;
				stream.SetLength(ms.Length);
				byte[] buffer = new byte[bufferSize];
				while (true)
				{
					int read = ms.Read(buffer, 0, buffer.Length);
					if (read == 0)
						break;
					stream.Write(buffer, 0, read);
				}
			}
			stream.Flush();
		}
		/// <summary>
		/// Decompresses a System.IO.Stream, using a System.IO.Compression.GZipStream.
		/// </summary>
		/// <param name="compressed">A System.IO.Stream containing compressed data.</param>
		/// <param name="uncompressed">A System.IO.Stream to write the uncompressed data into.</param>
		/// <exception cref="System.ArgumentNullException">compressed is null.</exception>
		/// <exception cref="System.ArgumentNullException">uncompressed is null.</exception>
		/// <exception cref="System.ArgumentException">Can not read from compressed.</exception>
		/// <exception cref="System.ArgumentException">Can not write to uncompressed.</exception>
		public static void Decompress(Stream compressed, Stream uncompressed)
		{
			if (compressed == null)
				throw new ArgumentNullException("compressed");
			if (uncompressed == null)
				throw new ArgumentNullException("uncompressed");
			if (!compressed.CanRead)
				throw new ArgumentException(canNotRead, "compressed");
			if (!uncompressed.CanWrite)
				throw new ArgumentException(canNotWrite, "uncompressed");

			using (var gzip = new GZipStream(compressed, CompressionMode.Decompress))
			{
				byte[] buffer = new byte[bufferSize];
				while (true)
				{
					int read = gzip.Read(buffer, 0, buffer.Length);
					if (read == 0)
						break;
					uncompressed.Write(buffer, 0, read);
				}
				uncompressed.Flush();
			}
		}
	}
}

EDIT: Hab noch mal was am bufferSize gemacht.

Schlagwörter: GZip, Stream, GZipStream, compress, decompress, uncompressed

Danke. Jup selber grad schon noch gersehn 😉

MfG TiltonJH

Beschreibung:

Auf der Suche nach Klassen und Methoden zum Wandeln von Byte[] in einen HexString und auch wieder zurück bin ich immer wieder auf halbfertige oder optimierungsbedürftige Snippets gestoßen.

Also dann doch selber machen. 😁

Hier nun meine Lösung.

Falls jmd noch Optimierungspotential findet, immer her damit. =)

using System;
using System.Text;

namespace Tools.Strings
{
	/// <summary>
	/// Provides methods for woking with hexadecimal values.
	/// </summary>
	public static class Hexadecimal
	{
		/// <summary>
		/// Determines if the <see cref="Char"/> is a hex digit.
		/// </summary>
		/// <param name="digit">A <see cref="Char"/>.</param>
		/// <returns><see langword="true"/>, if the given <see cref="Char"/> is a valid hex digit; - otherwise <see langword="false"/>.</returns>
		public static bool IsValidHexDigit(char digit)
		{
			return digit >= 0x30 && digit <= 0x39;
		}
		/// <summary>
		/// Determines if the <see cref="Char"/> is a lower case hex letter.
		/// </summary>
		/// <param name="letter">A <see cref="Char"/>.</param>
		/// <returns><see langword="true"/>, if the given <see cref="Char"/> is a lower case hex letter; - otherwise <see langword="false"/>.</returns>
		public static bool IsValidLowerCaseHexLetter(char letter)
		{
			return letter >= 0x61 && letter <= 0x66;
		}
		/// <summary>
		/// Determines if the <see cref="Char"/> is a upper case hex letter.
		/// </summary>
		/// <param name="letter">A <see cref="Char"/>.</param>
		/// <returns><see langword="true"/>, if the given <see cref="Char"/> is a upper case hex letter; - otherwise <see langword="false"/>.</returns>
		public static bool IsValidUpperCaseHexLetter(char letter)
		{
			return letter >= 0x41 && letter <= 0x46;
		}
		/// <summary>
		/// Determines if the <see cref="Char"/> is a valid hex char.
		/// </summary>
		/// <param name="hexChar">A <see cref="Char"/>.</param>
		/// <returns><see langword="true"/>, if the given <see cref="Char"/> is a valid hex char; - otherwise <see langword="false"/>.</returns>
		public static bool IsValidHexChar(char hexChar)
		{
			return Hexadecimal.IsValidHexDigit(hexChar) ||
				Hexadecimal.IsValidLowerCaseHexLetter(hexChar) ||
				Hexadecimal.IsValidUpperCaseHexLetter(hexChar);
		}
		/// <summary>
		/// Determines if the <see cref="String"/> is a valid hexString.
		/// </summary>
		/// <param name="hexString">A <see cref="String"/>.</param>
		/// <returns><see langword="true"/>, if the given <see cref="String"/> is a valid hexString; - otherwise <see langword="false"/>.</returns>
		public static bool IsValidHexString(string hexString)
		{
			if (hexString == null || hexString.Length == 0)
				return false;

			int i = 0;
			for (; i < hexString.Length; i++)
			{
				if (hexString[i] != ' ')
					break;
			}
			if (i >= hexString.Length)
				return false;

			if (hexString.Length - i >= 2)
			{
				char one = hexString[i];
				char two = hexString[i + 1];
				if (one == '0' && (two == 'x' || two == 'X'))
					i += 2;
			}

			if (i >= hexString.Length)
				return false;

			while (i < hexString.Length)
			{
				char c = hexString[i++];
				if (!(Hexadecimal.IsValidHexChar(c)))
					return false;
			}

			return true;
		}
		/// <summary>
		/// Returns the <see cref="Byte"/> representation of an hexDigits.
		/// </summary>
		/// <param name="hexDigit">The hexDigit.</param>
		/// <returns>The <see cref="Byte"/> representation of an hexDigits.</returns>
		/// <exception cref="FormatException"><paramref name="hexDigit"/> is not a valid hexDigit.</exception>
		public static byte ToByte(char hexDigit)
		{
			if (Hexadecimal.IsValidHexDigit(hexDigit))
				return (byte)(hexDigit - 0x30);
			else if (Hexadecimal.IsValidLowerCaseHexLetter(hexDigit))
				return (byte)(hexDigit - 0x57);
			else if (Hexadecimal.IsValidUpperCaseHexLetter(hexDigit))
				return (byte)(hexDigit - 0x37);
			else
				throw new FormatException("Is not a valid hexDigit.");
		}
		/// <summary>
		/// Returns the <see cref="Byte"/> representation of two hexDigits.
		/// </summary>
		/// <param name="leftHexDigit">The left hexDigit.</param>
		/// <param name="rightHexDigit">The right hexDigit.</param>
		/// <returns>The <see cref="Byte"/> representation of two hexDigits.</returns>
		public static byte ToByte(char leftHexDigit, char rightHexDigit)
		{
			return (byte)(Hexadecimal.ToByte(leftHexDigit) << 4 | Hexadecimal.ToByte(rightHexDigit));
		}
		/// <summary>
		/// Converts a hexString into an array of <see cref="Byte"/>.
		/// </summary>
		/// <param name="hexString">A hexString to convert into an array of <see cref="Byte"/>.</param>
		/// <returns>An array of <see cref="Byte"/> representing the given <paramref name="hexString"/>.</returns>
		/// <exception cref="ArgumentNullException"><paramref name="hexString"/> is <see langword="null"/>.</exception>
		/// <exception cref="FormatException"><paramref name="hexString"/> is not a valid hexString.</exception>
		public static byte[] ToBytes(string hexString)
		{
			if (hexString == null)
				throw new ArgumentNullException("hexString");
			if (hexString.Length == 0)
				return new byte[0];

			try
			{
				int i = 0;
				for (; i < hexString.Length; i++)
				{
					if (hexString[i] != ' ')
						break;
				}
				if (i >= hexString.Length)
					return new byte[0];

				if (hexString.Length - i >= 2)
				{
					char one = hexString[i];
					char two = hexString[i + 1];
					if (one == '0' && (two == 'x' || two == 'X'))
						i += 2;
				}

				if (i >= hexString.Length)
					return new byte[0];

				bool odd = (hexString.Length & 1) == 1;

				int length = hexString.Length - i >> 1;

				if (odd)
					length++;

				byte[] bytes = new byte[length];
				int j = 0;

				if (odd)
					bytes[j++] = ToByte(hexString[i++]);

				while (i < hexString.Length)
				{
					bytes[j++] = ToByte(hexString[i++], hexString[i++]);
				}

				return bytes;
			}
			catch (Exception ex)
			{
				throw new FormatException("Is not a valid hex string.", ex);
			}
		}
		/// <summary>
		/// Returns a hex char.
		/// </summary>
		/// <param name="value">A <see cref="Int32"/> representing an hex char.</param>
		/// <returns>A <see cref="Char"/> representation of a given hex char.</returns>
		/// <exception cref="ArgumentOutOfRangeException"><paramref name="value"/> is not in range: 0 &lt;= value &lt;= 15</exception>
		public static char ToHexChar(int value)
		{
			if (value >= 0 && value <= 9)
				return (char)(value + 0x30);
			else if (value > 9 && value <= 15)
				//lower case 0x57
				//upper case 0x37
				return (char)(value + 0x57);
			else
				throw new ArgumentOutOfRangeException("value", value, "valid range: 0 <= value <= 15");
		}
		/// <summary>
		/// Converts an array of <see cref="Byte"/> into an hexString.
		/// </summary>
		/// <param name="bytes">An array of <see cref="Byte"/> to convert.</param>
		/// <returns>An <see cref="String"/> representation of the given array of <see cref="Byte"/>.</returns>
		/// <exception cref="ArgumentNullException"><paramref name="bytes"/> is <see langword="null"/>.</exception>
		public static string ToString(byte[] bytes)
		{
			if (bytes == null)
				throw new ArgumentNullException("bytes");

			char[] chars = new char[bytes.Length << 1];
			for (int i = 0, bi = 0; i < chars.Length; )
			{
				byte b = bytes[bi++];
				chars[i++] = ToHexChar(b >> 4);
				chars[i++] = ToHexChar(b & 0xF);
			}
			return new string(chars);
		}
		/// <summary>
		/// Validates a <see cref="String"/> by removing all char which are not valid hex chars.
		/// </summary>
		/// <param name="hexString">A <see cref="String"/> to validate.</param>
		/// <returns>A validated <see cref="String"/>.</returns>
		/// <exception cref="ArgumentNullException"><paramref name="hexString"/> is <see langword="null"/>.</exception>
		public static string ValidateHexString(string hexString)
		{
			if (hexString == null)
				throw new ArgumentNullException("hexString");
			if (hexString.Length == 0)
				return hexString;

			int i = 0;
			for (; i < hexString.Length; i++)
			{
				if (hexString[i] != ' ')
					break;
			}
			if (i >= hexString.Length)
				return string.Empty;

			if (hexString.Length - i >= 2)
			{
				char one = hexString[i];
				char two = hexString[i + 1];
				if (one == '0' && (two == 'x' || two == 'X'))
					i += 2;
			}

			if (i >= hexString.Length)
				return string.Empty;

			var sb = new StringBuilder(hexString.Length - i);
			while (i < hexString.Length)
			{
				char c = hexString[i++];
				if (Hexadecimal.IsValidHexChar(c))
					sb.Append(c);
			}

			return sb.ToString();
		}
	}
}

EDIT: so was blödes, da waren noch ein paar käfer...
EDIT2: noch ne IsNullOrEmpty abfrage in IsValidHexString eingebaut
EDIT3: stark überarbeitet & kommentare eingefügt
EDIT4: weiter überarbeitet, leerzeichen am anfang werden nun übersprungen

Schlagwörter: <hexstring, hexadecimal, tostring, hexchar>

Na das is ja mal lustig. 😁

Das übliche hin und her zwischen statisch und singelton. Ich kann mich da immer nicht recht entscheiden. Aber du hast hier sicher recht.

Das war ursprünglich auch eine statische Klasse. Hab die extra weil ich die hierreinstellen wollte nochmal mit Kommentaren ausgestattet und in eine Singelton gewandelt.

Für alle die sie doch ganz gern statisch hätten, hier noch mal meine statische Version.

using System;

namespace Tools.Binary
{
	/// <summary>
	/// Provides methodes to reverse bits.
	/// For example: 10110110 --&gt; 01101101.
	/// </summary>
	public static class ReverseBits
	{
		/// <summary>
		/// Holds the look up table for the Tools.Binary.ReverseBits class.
		/// </summary>
		private static byte[] lookUpTable;

		/// <summary>
		/// Initializes the look up table if needed.
		/// </summary>
		public static void InitLookUpTable()
		{
			ReverseBits.InitLookUpTable(false);
		}
		/// <summary>
		/// Initializes the look up table.
		/// </summary>
		/// <param name="force">
		/// If true it will force to create a new look up table, even if it already exists.
		/// If false it will only create a new look up table if needed.
		/// </param>
		public static void InitLookUpTable(bool force)
		{
			if (ReverseBits.lookUpTable == null || force)
			{
				ReverseBits.lookUpTable = null;
				var newLookUpTable = new byte[byte.MaxValue + 1];
				for (int i = 0; i < byte.MaxValue + 1; i++)
				{
					newLookUpTable[byte.MaxValue - i] = ReverseBits.Reverse((byte)i);
				}
				ReverseBits.lookUpTable = newLookUpTable;
			}
		}

		/// <summary>
		/// Reverses the order of bits in one System.Byte.
		/// </summary>
		/// <param name="bits">The System.Byte to be reversed.</param>
		/// <returns>Returns the System.Byte with reversed bits.</returns>
		public static byte Reverse(byte bits)
		{
			if (ReverseBits.lookUpTable == null)
			{
				byte result = 0;
				for (int i = 0; i < 8; i++)
				{
					result <<= 1;
					result |= (byte)(bits & 1);
					bits >>= 1;
				}

				return result;
			}
			else
				return ReverseBits.lookUpTable[bits];
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt16.
		/// </summary>
		/// <param name="bits">The System.UInt16 to be reversed.</param>
		/// <returns>Returns the System.UInt16 with reversed bits.</returns>
		public static ushort Reverse(ushort bits)
		{
			return BitConverter.ToUInt16(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ushort result = 0;

			for (int i = 0; i < 16; i++)
			{
				result <<= 1;
				result |= (ushort)(bits & 1);
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt32.
		/// </summary>
		/// <param name="bits">The System.UInt32 to be reversed.</param>
		/// <returns>Returns the System.UInt32 with reversed bits.</returns>
		public static uint Reverse(uint bits)
		{
			return BitConverter.ToUInt32(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);
	
			/*
			uint result = 0;

			for (int i = 0; i < 32; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt64.
		/// </summary>
		/// <param name="bits">The System.UInt64 to be reversed.</param>
		/// <returns>Returns the System.UInt64 with reversed bits.</returns>
		public static ulong Reverse(ulong bits)
		{
			return BitConverter.ToUInt64(ReverseBits.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ulong result = 0;

			for (int i = 0; i < 64; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in the System.Byte[].
		/// </summary>
		/// <param name="bits">The System.Byte[] to be reversed.</param>
		/// <returns>Returns the System.Byte[] with reversed bits.</returns>
		public static byte[] Reverse(byte[] bytes)
		{
			if (bytes.Length > byte.MaxValue)
				ReverseBits.InitLookUpTable();

			var reversedData = new byte[bytes.Length];
			for (int i = 0; i < bytes.Length; i++)
			{
				reversedData[bytes.Length - 1 - i] = ReverseBits.Reverse(bytes[i]);
			}

			return reversedData;
		}
	}
}

Edit: noch eine bug beim force der look up table gefixed

Beschreibung:

Diese Singelton Klasse vertauscht Bits, so wird zB aus 10110110 --> 01101101. Das macht sie für verschiedene Datentypen, darunter byte, ushort, uint, ulong oder byte[]. Das Erweitern für andere Datentypen sollte nicht so schwer sein. Kann dann ja jeder selbst machen.

MfG

Tilton

using System;

namespace Tools.Binary
{
	/// <summary>
	/// Provides methodes to reverse bits.
	/// For example: 10110110 --&gt; 01101101.
	/// </summary>
	public  sealed class ReverseBits
	{
		/// <summary>
		/// Holds the current singelton for the Tools.Binary.ReverseBits class.
		/// </summary>
		public static readonly ReverseBits Instance = new ReverseBits();

		/// <summary>
		/// Initializes a new instance of the Tools.Binary.ReverseBits class.
		/// </summary>
		private ReverseBits()
		{ }

		/// <summary>
		/// Holds the look up table for the current Tools.Binary.ReverseBits class.
		/// </summary>
		private byte[] lookUpTable;

		/// <summary>
		/// Initializes the look up table if needed.
		/// </summary>
		public void InitLookUpTable()
		{
			this.InitLookUpTable(false);
		}
		/// <summary>
		/// Initializes the look up table.
		/// </summary>
		/// <param name="force">
		/// If true it will force to create a new look up table, even if it already exists.
		/// If false it will only create a new look up table if needed.
		/// </param>
		public void InitLookUpTable(bool force)
		{
			if (this.lookUpTable == null || force)
			{
				this.lookUpTable = null;
				var newLookUpTable = new byte[byte.MaxValue + 1];
				for (int i = 0; i < byte.MaxValue + 1; i++)
				{
					newLookUpTable[byte.MaxValue - i] = this.Reverse((byte)i);
				}
				this.lookUpTable = newLookUpTable;
			}
		}

		/// <summary>
		/// Reverses the order of bits in one System.Byte.
		/// </summary>
		/// <param name="bits">The System.Byte to be reversed.</param>
		/// <returns>Returns the System.Byte with reversed bits.</returns>
		public byte Reverse(byte bits)
		{
			if (this.lookUpTable == null)
			{
				byte result = 0;
				for (int i = 0; i < 8; i++)
				{
					result <<= 1;
					result |= (byte)(bits & 1);
					bits >>= 1;
				}

				return result;
			}
			else
				return this.lookUpTable[bits];
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt16.
		/// </summary>
		/// <param name="bits">The System.UInt16 to be reversed.</param>
		/// <returns>Returns the System.UInt16 with reversed bits.</returns>
		public ushort Reverse(ushort bits)
		{
			return BitConverter.ToUInt16(this.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ushort result = 0;

			for (int i = 0; i < 16; i++)
			{
				result <<= 1;
				result |= (ushort)(bits & 1);
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt32.
		/// </summary>
		/// <param name="bits">The System.UInt32 to be reversed.</param>
		/// <returns>Returns the System.UInt32 with reversed bits.</returns>
		public uint Reverse(uint bits)
		{
			return BitConverter.ToUInt32(this.Reverse(BitConverter.GetBytes(bits)), 0);
	
			/*
			uint result = 0;

			for (int i = 0; i < 32; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in one System.UInt64.
		/// </summary>
		/// <param name="bits">The System.UInt64 to be reversed.</param>
		/// <returns>Returns the System.UInt64 with reversed bits.</returns>
		public ulong Reverse(ulong bits)
		{
			return BitConverter.ToUInt64(this.Reverse(BitConverter.GetBytes(bits)), 0);

			/*
			ulong result = 0;

			for (int i = 0; i < 64; i++)
			{
				result <<= 1;
				result |= bits & 1;
				bits >>= 1;
			}

			return result;
			*/
		}
		/// <summary>
		/// Reverses the order of bits in the System.Byte[].
		/// </summary>
		/// <param name="bits">The System.Byte[] to be reversed.</param>
		/// <returns>Returns the System.Byte[] with reversed bits.</returns>
		public byte[] Reverse(byte[] bytes)
		{
			if (bytes.Length > byte.MaxValue)
				this.InitLookUpTable();

			var reversedData = new byte[bytes.Length];
			for (int i = 0; i < bytes.Length; i++)
			{
				reversedData[bytes.Length - 1 - i] = this.Reverse(bytes[i]);
			}

			return reversedData;
		}
	}
}

Edit: noch eine bug beim force der look up table gefixed

Schlagwörter: bits, reverse, drehen, vertauschen

Beschreibung:

Hier und da haben Leute behauptet das das .Net Framework eine CRC32 Klasse schon beinhaltet, finden konnte ich diese aber leider nicht. (Wenn es die doch schon gibt sagt mir doch bitte mal wo.)
Da hab ich mich mal hingesetzt und selber eine geschrieben. Diese wollte ich der Community nicht vorenthalten. 😁

Ich habe es selbst mehrfach getestet, aber falls jemand einen Käfer finden solltet, sagt doch bitte bescheid.

MfG Tilton

using System;

namespace Tools.Crc
{
	public class Crc32
	{
		/// <summary>
		/// The reversed polynomial value of: 
		/// x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1 = 0x04C11DB7
		/// reverse --&gt; 0xEDB88320
		/// </summary>
		public const uint DefaultPolynomial = 0xEDB88320;
		/// <summary>
		/// Computes the polynomial value from a polynomial formular.
		/// </summary>
		/// <param name="fromular">A System.Int32[].
		/// <example>
		/// x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1
		/// --&gt;
		/// new int[] { 32, 26, 23, 22, 16, 12, 11, 10, 8, 7, 5, 4, 2, 1, 0 };</example></param>
		/// <returns>Polynomial value.</returns>
		public static uint ComputePolynomial(params int[] fromular)
		{
			uint number = 0;
			for (int i = 0; i < fromular.Length; i++)
			{
				number |= (1u << fromular[i]);
			}
			return number;
		}

		/// <summary>
		/// Initializes a new instance of the Tools.Crc.Crc32 class
		/// using the Tools.Crc.Crc32.DefaultPolynomial.
		/// </summary>
		public Crc32()
			: this(Crc32.DefaultPolynomial)
		{ }
		/// <summary>
		/// Initializes a new instance of the Tools.Crc.Crc32 class.
		/// </summary>
		/// <param name="polynomial">A System.UInt32 value.</param>
		public Crc32(uint polynomial)
		{
			this.Polynomial = polynomial;
			this.LookUpTable = this.CreateLookUpTable(this.Polynomial);
		}

		/// <summary>
		/// Gets the polynomial used in the Tools.Crc.Crc32.
		/// </summary>
		public uint Polynomial
		{
			get;
			private set;
		}
		/// <summary>
		/// Gets the look up table for the used polynomial of the Tools.Crc.Crc32.
		/// </summary>
		public uint[] LookUpTable
		{
			get;
			private set;
		}

		/// <summary>
		/// Computes the CRC32 hash code for the given data.
		/// </summary>
		/// <param name="data">A System.Byte[].</param>
		/// <returns>Returns the computed CRC32 hash code for the given data.</returns>
		/// <exception cref="System.ArgumentNullException">data is null.</exception>
		/// <exception cref="System.ArgumentOutOfRangeException">data.Lenght == 0.</exception>
		public uint ComputeHash(byte[] data)
		{
			if (data == null)
				throw new ArgumentNullException("data");
			if (data.Length == 0)
				throw new ArgumentOutOfRangeException("data");

			uint crc = this.GetInitializedValue();

			for (long i = 0; i < data.LongLength; i++)
			{
				crc = this.ComputeHash(crc, data[i]);
			}

			return this.GetFinalizedValue(crc);
		}
		/// <summary>
		/// Computes the CRC32 hash code for the given data.
		/// </summary>
		/// <param name="data">A System.IO.Stream.</param>
		/// <returns>Returns the computed CRC32 hash code for the given data.</returns>
		/// <exception cref="System.ArgumentNullException">data is null.</exception>
		/// <exception cref="System.NotSupportedException">The stream does not support reading.</exception>
		public uint ComputeHash(System.IO.Stream data)
		{
			if (data == null)
				throw new ArgumentNullException("data");
			if (!data.CanRead)
				throw new NotSupportedException("The stream does not support reading.");

			uint crc = this.GetInitializedValue();

			using (var br = new System.IO.BinaryReader(data))
			{
				try
				{
					while (true)
					{
						crc = this.ComputeHash(crc, br.ReadByte());
					}
				}
				catch (System.IO.EndOfStreamException) { }
			}

			return this.GetFinalizedValue(crc);
		}
		/// <summary>
		/// Computes the CRC32 hash code value for the given data.
		/// Initializing and finalizing the CRC32 hash code value is not done here 
		/// and may need to be done elsewhere.
		/// </summary>
		/// <param name="crcValue">The initialized CRC32 hash code value to compute with.</param>
		/// <param name="data">The data to compute with.</param>
		/// <param name="offset">The zero-based byte offset in data at which to begin computing the CRC32 hash code.</param>
		/// <param name="count">The number of bytes to be used in the data array.</param>
		/// <returns>Returns the computed CRC32 hash code for the given data. It has not been not finalized.</returns>
		/// <exception cref="System.ArgumentNullException">data is null.</exception>
		/// <exception cref="System.ArgumentOutOfRangeException">offset or count is negative.</exception>
		/// <exception cref="System.ArgumentException">The sum of offset and count is larger than the data length.</exception>
		public uint ComputeHash(uint crcValue, byte[] data, uint offset, uint count)
		{
			if (data == null)
				throw new ArgumentNullException("data", "is null.");
			if (offset < 0)
				throw new ArgumentOutOfRangeException("offset", "is negative.");
			if (count < 0)
				throw new ArgumentOutOfRangeException("count", "is negative.");
			if (data.LongLength < (long)offset + (long)count)
				throw new ArgumentException("The sum of offset and count is larger than the data length.");

			for (long i = 0; i < count; i++)
			{
				crcValue = this.ComputeHash(crcValue, data[offset + i]);
			}

			return crcValue;
		}
		/// <summary>
		/// Computes the CRC32 hash code value for the given data.
		/// Initializing and finalizing the CRC32 hash code value is not done here 
		/// and may need to be done elsewhere.
		/// </summary>
		/// <param name="crcValue">The initialized CRC32 hash code value to compute with.</param>
		/// <param name="data">The data to compute with.</param>
		/// <returns>Returns the computed CRC32 hash code for the given data. It has not been not finalized.</returns>
		private uint ComputeHash(uint crcValue, byte data)
		{
			return this.LookUpTable[(byte)crcValue ^ data] ^ (crcValue >> 8);
		}

		/// <summary>
		/// Creates a look up table for the given polynomial.
		/// </summary>
		/// <param name="polynomial">The polynomial to work with.</param>
		/// <returns>Returns a look up table for the given polynomial</returns>
		private uint[] CreateLookUpTable(uint polynomial)
		{
			var table = new uint[256];
			for (uint i = 0; i < table.Length; i++)
			{
				uint r = i;
				for (int j = 0; j < 8; j++)
				{
					if ((r & 1) != 0)
						r = (r >> 1) ^ polynomial;
					else
						r >>= 1;
				}
				table[i] = r;
			}
			return table;
		}

		/// <summary>
		/// Gets the finalized CRC32 hash code value.
		/// </summary>
		/// <param name="value">The CRC32 hash code value to be finalized.</param>
		/// <returns>Returns the finalized CRC32 hash code value.</returns>
		public uint GetFinalizedValue(uint value)
		{
			return value ^ uint.MaxValue;
		}
		/// <summary>
		/// Gets an initialized CRC32 hash code value.
		/// </summary>
		/// <returns>Returns an initialized CRC32 hash code value.</returns>
		public uint GetInitializedValue()
		{
			return uint.MaxValue;
		}

	}
}

Schlagwörter: crc, crc32, look up table, hash code

heute is wieder so ein tag...
gleich noch was gefunden

http://www.mikrocontroller.net/topic/22952

man beachte

[...]
das könnte man mit if(b&1)crc^=0xA001; bewerkstelligen,
jedoch ist         b&1?crc^=40961:0;   2 Buchstaben kürzer, was mit
persönlich gefällt
                                       (das :0 braucht man nur aus
syntaktischen Gründen).
                                       (außerdem geht if() nicht in der
runden for-Klammer s.u.)

also, geschoben werden muss immer:

c=c >> 1  gleichbedeuten mit c>>=1  gleichbedeutend mit c/=2
(zumindest wenn c unsigned ist)

Beim nächsten Durchgang ist Bit1 von Input Data von Interesse, also
schiebe ich es an die Stelle d0:
d=d >> 1  c>>=1  c/=2

statt  for(j=0;j<8;j++)  schreibe ich  for(j=8;j;j--)   wieder 2
Buchstaben gespart  (-; (das mittlere j ist eine

Kurzform für j!=0)

und statt
for(j=8;j;j--){b=c^d;c/=2;d/=2;if(b&1)crc^=0xA001;} schreibe ich kurz
for(j=8;j;j--,b=c^d,c/=2,d/=2,b&1?c^=40961:0); schade, dass das
überflüssige :0 syntaktisch sein muss
[...]

"2 Buchstaben gespart" ahhhhhhhh...

MfG

Mahlzeit,

also überflüssige if konstrukte

...
if (ausdruck)
	return true;
else
	return false;
...

oder auch

i = ++i;

seh ich ja noch mal ein, hab ich also ich vor jahren die ersten schritte in der programmierung gemacht habe, mitunter auch noch getan. so was macht man doch nicht mutwillig, sondern weil man es nicht besser weiß.

viel schlimmer finde ich da die jungs / mädels die früher viel mit c++ gemacht haben und jetzt ihren sicherlich guten c++ code 1:1 in C# umsetzten.

namespace SevenZip.Compression.LZMA
{
[...]
	public class Encoder : ICoder, ISetCoderProperties, IWriteCoderProperties
	{
		[...]
		public void Create(int numPosBits, int numPrevBits)
		{
			if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
				return;
			m_NumPosBits = numPosBits;
			m_PosMask = ((uint)1 << numPosBits) - 1;
			m_NumPrevBits = numPrevBits;
			uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
			m_Coders = new Encoder2[numStates];
			for (uint i = 0; i < numStates; i++)
				m_Coders[i].Create();
		}
		[...]
	}
}

ich nich mal sicher ob das geht, das feld is zwar neu angelegt, aber des wegen sind doch noch lange keine elemente drin... 🤔

wer sich sowas mal aus der nähe anschaun mag kann sich zb die das 7zip SDK http://www.7-zip.org/sdk.html in der c# ausgabe anschaun. sehr sehr grusselig...

soll heisen auch bekannte und gute programmieren machen quatsch in sprachen, in dehen sich nicht richtig auskennen.

MfG Tilton