Forenbeiträge von edsplash Ingesamt 390 Beiträge
Als ich früher noch PHP programmiert habe, benutzte ich meistens UModel von Altova...
Hab es mal kurz angetestet:
Suche nach ähnlicher Musik wie Rise Against und kriege Ergebnisse wie As I Lay Dying oder Papa Roach 😉 Sind zwar auch tolle Bands, allerdings wohl alle einem anderem Genere zuzuschreiben! Aber ist sicher eine gute Idee, wenn's dann ausgereift ist 😉
hab mich auch schon gefragt wie man das macht... irgendwie benötigte man die audiodaten um damit eine fft zu machen. Hab auch schon danach gesucht, aber nichts gefunden...
MemoryStream myStream = new MemoryStream();
BinaryFormatter binF = new BinaryFormatter();
binF.Serialize(myStream, liste);
oder sowas in der Art 😉 dann kannst du den MemoryStream ans Clipboard übergeben und beim herausholen einfach binF.Deserialize() auf den Stream ausführen, den du aus dem Clipboard hast.
Und wenn du den MemoryStream, den du bekommst auf die "traditionelle" Art deserialisierst ?
Aber als erstes in der Methode Add holst Du dir doch auch die Liste aus dem Clipboard und dort funktioniert es ?
Was für einen Wert hat dann Format ?
hm... Irgendwie versteh ich Dein Problem nicht ganz...
Also so wie ich das sehe, liegt es an Deinem Format, probier mal "MeinFormat" durch DataFormats.Serializable zu ersetzen.
Wenn man das Attribute [Serializable] verwendet, muss man i.d.R. ISerializable nicht implementieren!
Ich zähle mich auch mal zur Brötchenfraktion 😉
Tatsächlich bin ich aber in der Ausbildung zum Elektroniker, befasse mich aber momentan hauptsächlich mit C# und kurzfristig Typo3. Ich ziehe ebenfalls in Erwägung später Elektrotechnik oder Informatik an einer Fachhochschule zu "studieren", obwohl mir von Letzterem bereits abgeraten wurde.
i = 3; //sollte nicht funktionieren
Um "funktionieren" nochmals genauer zu spezifizieren:
Im allgemeinen Sinne "funktioniert" es schon - keine Compilerfehler, keine Exceptions.
Also bei mir gibts einen Fehler 🙂
Fehler 1 "i" ist "foreach-Iterationsvariable", daher ist die Zuordnung nicht möglich. \Program.cs 12 5
ist genau das selbe problem
foreach (byte i in zahl)
{
zahl[i] = 3; // Hier ist die Absturz
Console.WriteLine(zahl[i]);
}
beim ersten durchlaufen dieser Schleife hast du vielleicht in i den Wert 2 gespeichert. Dadurch greifst du dann auf das Element 2 des Arrays zu, was natürlich funktioniert.
foreach (byte i in zahl)
{
i = 3; //sollte nicht funktionieren
}
Merke: in der foreach Schleife bekommst du immer das jeweilige Objekt und nicht einen Index!
Was ich sehr sinvoll fände, wär ein Pluginsystem, welches erlaubt direkt Winamp Plugins zu verwenden, bin mir allerdings nicht sicher ob das funktioniert.
Die meisten Datentypen bieten eine Methode "ToString()" an. Diese Methode kannst Du auf Deinen Wert anwenden und erhälst dabei einen String. Auf die einzelnen Elemente eines Strings kannst Du dann mit deinString[index] zugreifen.
Meines Wissens kann man das nicht direkt machen.
Entweder macht man es über den String, was sicher einfacher ist, oder wie schon erwähnt wurde mit dem Modulo Operator. Da du ja sowiso am üben bist, kannst du dir ja gleich eine Methode schreiben die dir das Array zurückgibt. IntToArray(int Val);
Falls du dann noch möchtest, kannst du es immer noch generisch machen o.Ä.
Bin kurz davor mir eine akustische Gitarre zuzulegen, um mal ein bisschen das nachzuspielen, was ich sonst so höre. Bis ich das allerdings könnte ginge es Jahrzehnte 😉
Sieht ganz nett aus! Was mir gerade so aufgefallen ist:
- Der Player stürzt ab, wenn ich versuche meinen ganzen Musikordner zur Wiedergabeliste hinzuzufügen.
- Funktioniert der Seeker wohl noch nicht richtig. D.h. Er springt zwar jedesmal ein wenig vor/zurück, wenn ich irgendwo hin klicke, allerdings passiert mit dem Lied nichts.
Das Dumme an diesen 30 Tagen ist, dass man als Benutzer teilweise nur die Uhr von Windows zurückstellen muss, um das Programm wieder benutzen zu können.
Kann man nicht auch mit dem Visual Studio nativen Code schreiben ?
Es gibt ja auch die Möglichkeit Win32/MFC/ATL Projekte zu erstellen.
Ansonsten finde ich den Borland C++ Builder relativ gemütlich.
ObjectHandle oh = System.Activator.CreateInstance(null, "Namespace1.Klasse");
object cObj = oh.Unwrap();
nur als Beispiel 😉
ich hatte jeweils das Problem, dass ich Klassen aus dem gleichen Namespace erstellen wollte, die CreateInstance Methode aber scheinbar in jedem Fall den Namespace benötigt.
Also rein von der Technik her ist das kein Ding...
//hexVal = 0111 1111
byte hexVal = 0x7F;
//t1 = 0000 1111
byte t1 = (byte)(hexVal & 0x0F);
//t2 = 0111 0000
byte t2 = (byte)(hexVal & 0xF0);
//final = 1111 0111
byte final = (byte)((t1 << 4) | (t2 >> 4));
Für die FFT gibt es bereits eine Lösung
Bei mir hat es nicht funktioniert. Ich hatte jeweils die Fehlermeldung das VS2005 benötigt würde...
[edit]
Hab grad gesehen das Du die selbe Fehlermeldung bekommst. Ich warte immernoch auf einen Fix...
[/edit]
Was mir zusätzlich gefallen würde, wäre ein vereinfachter Zugriff auf Windows Komponenten direkt aus dem .NET Framework, so dass man z.b. direkt aktive Fenster, Taskbar Höhe und sonst allgemeine Windows Sachen, welche man vorher nur mit Dlls etc. ansprechen konnte, nun direkt aus dem Framework ansprechen könnte.
ich habe gesehen wie es mit vb funktioniert hat also muss es wohl über .net auch irgendwie möglich sein...
Windows-Anwendungen sind grundsätzlich nicht echtzeitfähig. Bei .NET kommt der GC als "Pausenmacher" noch dazu. Das heisst nicht, dass du 20ms Latenzen nicht schaffen kannst, aber eben nicht zuverlässig.
Das ist mir soweit schon klar. Es hat mich allerdings erstaunt, das zwischen den beiden Aufrufen, wo ja scheinbar nichts dazwischen ist, trotzdem eine Zeit von 20ms verstreicht. Das ist dann wohl der Preis für die Bequemlichkeit mit dem GC 😉. Naja, wenns gar nicht klappt, muss ich eben einen Kontroller dazwischen schieben, dann müste ich nurnoch die Daten über RS232 reinschicken und der Kontroller übernimmt die Umwandlung in I2C. Ich werde es jedenfalls nochmals mit obigem Code probieren, sobald ich die Zeit habe.
Für solche Geschichten musst du einen Treiber schreiben. Mit einer Windows-Anwendung geht das nicht.
ich habe gesehen wie es mit vb funktioniert hat also muss es wohl über .net auch irgendwie möglich sein... naja, ich werds am montag mal mit dem kernel32 probieren
http://www.pinvoke.net/default.aspx/kernel32.SetCommState
finde leider keine brauchbare anwendung und die msdn spuckt auch nur das aus
http://msdn.microsoft.com/en-us/library/aa363436(VS.85).aspx
das obige Beispiel habe ich aus dem Netz.
ok, hab das mal probiert.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.IO;
using System.Threading;
namespace setComTest {
class Program {
static void Main(string[] args) {
DCB info = new DCB();
Schnittstelle test = new Schnittstelle(11, ref info);
for ( ; ; ) {
test.setClock(ref info);
test.clearClock(ref info);
Thread.Sleep(2000);
}
}
}
public struct DCB {
public uint DCBlength; /* sizeof(DCB) */
public uint BaudRate; /* Baudrate at which running */
public uint fBinary; /* Binary Mode (skip EOF check) */
public uint fParity; /* Enable parity checking */
public uint fOutxCtsFlow; /* CTS handshaking on output */
public uint fOutxDsrFlow; /* DSR handshaking on output */
public uint fDtrControl; /* DTR Flow control */
public uint fDsrSensitivity; /* DSR Sensitivity */
public uint fTXContinueOnXoff;/* Continue TX when Xoff sent */
public uint fOutX; /* Enable output X-ON/X-OFF */
public uint fInX; /* Enable input X-ON/X-OFF */
public uint fErrorChar; /* Enable Err Replacement */
public uint fNull; /* Enable Null stripping */
public uint fRtsControl; /* Rts Flow control */
public uint fAbortOnError; /* Abort all reads and writes on Error */
public uint fDummy2; /* Reserved */
public ushort wReserved; /* Not currently used */
public ushort XonLim; /* Transmit X-ON threshold */
public ushort XoffLim; /* Transmit X-OFF threshold */
public byte ByteSize; /* Number of bits/public byte, 4-8 */
public byte Parity; /* 0-4=None,Odd,Even,Mark,Space */
public byte StopBits; /* 0,1,2 = 1, 1.5, 2 */
public char XonChar; /* Tx and Rx X-ON public character */
public char XoffChar; /* Tx and Rx X-OFF public character */
public char ErrorChar; /* Error replacement public char */
public char EofChar; /* End of Input public character */
public char EvtChar; /* Received Event public character */
public ushort wReserved1; /* Fill for now. */
}
/// <summary>
/// Summary description for Schnittstelle.
/// </summary>
public class Schnittstelle {
const int DTR_CONTROL_DISABLE = 0x00;
const int DTR_CONTROL_ENABLE = 0x01;
const int DTR_CONTROL_HANDSHAKE = 0x02;
const int RTS_CONTROL_DISABLE = 0x00;
const int RTS_CONTROL_ENABLE = 0x01;
const int RTS_CONTROL_HANDSHAKE = 0x02;
const int RTS_CONTROL_TOGGLE = 0x03;
const int NOPARITY = 0;
const int ODDPARITY = 1;
const int EVENPARITY = 2;
const int MARKPARITY = 3;
const int SPACEPARITY = 4;
const int ONESTOPBIT = 0;
const int ONE5STOPBITS = 1;
const int TWOSTOPBITS = 2;
const int XON = 0x11;
const int XOFF = 0x13;
private FileStream ComPort;
[DllImport("Kernel32.dll")]
static extern bool GetCommState(IntPtr hCOM, ref DCB dbcSerialPortStream);
[DllImport("Kernel32.dll")]
static extern bool SetCommState(IntPtr hCOM, ref DCB dbcSerialPortStream);
public Schnittstelle(int nComPort, ref DCB dcb) {
String str = "COM" + String.Format("{0:#}:", nComPort);
ComPort = new FileStream(str, FileMode.Open, FileAccess.ReadWrite, FileShare.None, 64000);
dcb.BaudRate = 38400;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.fBinary = 1;
dcb.fOutxCtsFlow = 0;
dcb.fOutxDsrFlow = 0;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fDsrSensitivity = 0;
dcb.fOutX = 0;
dcb.fInX = 0;
dcb.fErrorChar = 0;
dcb.fNull = 0;
dcb.fRtsControl = RTS_CONTROL_TOGGLE;
dcb.fAbortOnError = 0;
dcb.XonLim = 50;
dcb.XoffLim = 50;
dcb.XonChar = (char)XON;
dcb.XoffChar = (char)XOFF;
}
public void setClock(ref DCB dcb){
dcb.fRtsControl = RTS_CONTROL_ENABLE;
SetCommState(ComPort.Handle, ref dcb);
}
public void clearClock(ref DCB dcb) {
dcb.fRtsControl = RTS_CONTROL_DISABLE;
SetCommState(ComPort.Handle, ref dcb);
}
public void Close() {
ComPort.Close();
}
}
}
Bekomme aber beim Aufruf von
ComPort = new FileStream(str, FileMode.Open, FileAccess.ReadWrite, FileShare.None, 64000);
eine System.NotSupportedException -> "Das angegebene Pfadformat wird nicht unterstützt."
public class TWISerialProvider : ITWIHardwareProvider {
private SerialPort _sPort;
public TWISerialProvider(string device, int baudrate) {
_sPort = new SerialPort(device, baudrate, Parity.None, 8, StopBits.One);
}
public void Open() {
if (_sPort.IsOpen == false) {
_sPort.Open();
}
}
//Implementierte Eigenschaften
public TWILevels DataLine {
get {
return GetDataLine();
}
set {
SetDataLine(value);
}
}
//Implementierte Eigenschaften
public TWILevels ClockLine {
get {
return GetClockLine();
}
set {
SetClockLine(value);
}
}
//<summary>
//Setzt die Taktleitung
//</summary>
private void SetClockLine(TWILevels state){
if (state == TWILevels.High) {
_sPort.RtsEnable = true;
}
else {
_sPort.RtsEnable = false;
}
}
//<summary>
//Setzt die Datenleitung
//</summary>
private void SetDataLine(TWILevels state) {
if (state == TWILevels.High) {
_sPort.DtrEnable = true;
}
else {
_sPort.DtrEnable = false;
}
}
//<summary>
//Liest die Taktleitung
//</summary>
private TWILevels GetClockLine() {
if (_sPort.RtsEnable) {
return TWILevels.High;
}
else {
return TWILevels.Low;
}
}
//<summary>
//Liest die Datenleitung
//</summary>
private TWILevels GetDataLine() {
if (_sPort.DtrEnable) {
return TWILevels.High;
}
else {
return TWILevels.Low;
}
}
}
[Flags]
public enum TWILevels : byte {
Low = 0x00,
High = 0x01
};
Ich hoffe, dass es nun klar ist.
Hi...
Ich habe mir fest vorgenommen eine I2C Klasse für C# zu schreiben.
Die Grundlage ist sehr einfach. Ich nutze eine Serielle Schnittstelle, brauche davon allerdings nur die Status Leitungen.
DTR und RTS zum senden
DSR und CTS zum empfangen
Nun habe ich angefangen meine Klasse zu schreiben und es sieht auf den ersten Blick ganz gut aus. Allerdings habe ich ein kleines Problem.
public void ClockPulse() {
_device.ClockLine = TWILevels.High;
_device.ClockLine = TWILevels.Low;
}
diese Methode brauche ich um mit der Clock Leitung das aktuelle Bit zu bestätigen. Wie man sehen kann, schalte ich die Clock Leitung auf High und wieder zurück auf Low. Obwohl ich offenbar keine Wartezeit zwischen den beiden Funktionen habe, Messe ich da eine Zeit von 20ms zwischen High und Low.
Die ClockLine Eigenschaft setzt mehr oder weniger direkt oben genannte Status Leitungen.
Nun zu meinen Fragen:
- Warum dauert das 20ms obwohl nichts dazwischen liegt ?
- Kann ich das irgendwie beschleunigen? Das wäre sehr nützlich, da ich nur schon für den normalen Modus eine Clock Frequenz von etwa 440kHz benötige und wenn der Impuls, den ich da gebe alleine schon 20ms braucht komme ich an diese Frequenz nie und nimmer ran.
Ich hatte es mal für ein paar Tage installiert. Eigentlich kann ich nichts daran aussetzen. Vorallem das MediaCenter, welches selbstständig die Treiber für meine TV-Karte installiert & die Sender eingestellt hat, fand ich ganz gut. Die beiden einzigen Sachen, die mir nicht gefallen haben, waren, dass man die Polling-Rate des USB-Ports nicht verändern konnte und das gewisse Tools die die Gamma erhöhen sollten, im Vollbild Modus nicht funktionierten.
vielleicht hilft das weiter 😉
12: Ein wenig C++ (wohl eher ohne das ++), habe allerdings das Wenigste verstanden 😁
Danach mit basic ein wenig programmieren gelernt -> kurzer Ausflug zu Visual Basic.
Hab mir später dann ein CGI/Perl Buch gekauft um ein wenig in die Webprogrammierung einzusteigen. Später hab ich dann ein Wenig in PHP programmiert.
16: Durch meine Ausbildung habe ich dann intensiver C programmiert, wegen der Berufsschule auch C für Mikrocontroller.
18: Intensiv PHP, war daran ein CMS für meine Homepage zu entwickeln. Blieb aber stehen weil ich zu wenig Ahnung von OO hatte und das CMS nicht 50/50 programmieren wollte.
Nebenbei in der Berufsschule ein wenig VHDL programmiert,
danach in der Firma mit CVI (C) programmiert und ironischerweise hab ich da wirklich programmieren gelernt und endlich begriffen was es an der OO wirklich zu schätzen gibt 😁
und nun programmiere ich in der Firma und nebenbei ein wenig C#
Natürlich kannst und solltest du dabei EventHander<T> verwenden.
Siehe auch
> .
Wollte es eigentlich auf diese Art lösen, wusste nur nicht genau wie 😉
Danke jedenfalls für die Hilfe
Hi
Hab mal wieder ein kleines Problem.
Folgendes ist gegeben.
Ich habe eine Klasse (Form1) die eine weitere Klasse(ClientEngine) nutzt.
Die ClientEngine macht einen UDP Port auf und wartet auf gesendete Daten. Sobald irgendwelche Daten empfangen werden, wird eine ParserMethode aufgerufen, welche die gesendeten Daten analysiert und anhand der Daten verschiedene Events auslöst. Dazu hab ich mir mehrere EventHandler und einen einzigen delegate der auf alle Events anwendbar ist erstellt.
public event EngineEventHandler currentChanged;
public event EngineEventHandler playlistAvailable;
public event EngineEventHandler votingAvailable;
public event EngineEventHandler equalizerChanged;
public event EngineEventHandler volumeChanged;
public delegate void EngineEventHandler(object sender, object Args);
Wenn ich nun z.b. den volumeChanged Event auslösen will, will ich im zweiten Parameter (object Args) ein byte übergeben. Wenn ich nun den playlistAvailable Event auslösen will, möchte ich im zweiten Parameter (object args) eine Queue übergeben. Bisher hab ich das so gelöst, dass ich die zu übergebenden Daten mit dem as Operator in ein object gewandelt habe. Das sieht dann folgendermassen aus
//Event auslösen
volumeChanged(this, volume as object);
und
//Event auslösen
playlistAvailable(this, Playlist as object);
Allerdings scheint mir das nicht so sauber zu sein, da ich dann beim verarbeiten des Events das object zurückcasten muss z.b. (byte)Args beim volumeChanged Event. Was ich auch machen könnte wären mehrere delegates: Also z.b. einmal mit dem zweiten Parameter als byte und einmal mit dem zweiten Parameter als Queue.
public delegate void EngineVolumeHandler(object sender, byte Args);
public delegate void EnginePlaylistHandler(object sender, Queue Args);
Allerdings müsste ich so für praktisch jeden Event ein entsprechendes Delegate definieren, was mir auch sinnlos erscheint. Am liebsten wäre mir ein Delegate mit einem dynamischen Typ. Als sowas in der Richtung
public delegate void EngineEventHandler(object sender, <T> Args);
Damit ich beim auslösen des Events festlegen kann welcher Typ das zweite Argument hat. Allerdings ist mir nicht ganz klar wie man das realisieren könnte.
Hat jemand eine Idee wie man dieses Problem am elegantesten lösen könnte ?
freundliche Grüsse
edsplash
Da wir in meiner Lehrfirma endlich von Borland weggekommen sind und uns kurzerhand VS Express installiert haben. Habe ich den Auftrag bekommen mich nach guten Büchern umzusehen. Darin sollten alle wichtigen Themen wie z.b. Sprachgrundlagen von C#, Forms, Dateisystem Zugriff, Grundlegende .NET Klassen behandelt werden. Da allerdings die meisten Lehrlinge nur mit C (CVI) vertraut sind wäre eine umfassende Einführung in die Objektorientierung ganz nützlich. Weiter wäre es von Vorteil, wenn das Buch ebenfalls tiefer in die Materie (Multihreading, Datenbank-Programmierung etc. und evtl. auch WPF) eingehen würde.
Ich hoffe es gibt überhaupt so ein Allrounder Buch und freue mich auf Eure Empfelungen.
Gruss
Guten Morgen
Hatte heute das Problem, dass mein Compiler immer folgende Exception warf:
Fehler bei der Anforderung des Berechtigungstyps System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
Mit der Forumsuche habe ich dann rausgefunden, dass es etwas mit dem Netzlaufwerk, auf dem mein ganzer Code gespeichert ist, zu tun hat! Weiter habe ich gelesen das man die Richtlinien auf FullTrust stellen soll in der Verwaltung!
Allerdings bin ich mir nicht ganz sicher in welchem Bereich. In der .NET Konfiguration gibt es diese "Laufzeitsicherheitsrichtlinie" allerdgins weis ich, wie gesagt, nicht welchen Codegruppen ich FullTrust geben muss um den Code vom Netzlaufwerk ausführen zu können.
Weiter macht es mich stutzig, dass ich in der Verwaltung nur eine ".NET-Framework 1.1 Konfiguration" habe, obwohl ich das VS 2008 Express installiert habe. Ich deute das so, dass auf diesem Rechner scheinbar nur das .NET 1.1 installiert ist obwohl VS 2008 ebenfalls installiert ist. Hat dies irgendwelche Auswirkungen ?
Vielen Dank im Voraus !
hi..
Ich habe mir zu diesem Thema schon einiges durchgelesen und habe es nun auch mehr oder weniger verstanden. Allerdings gibt es immernoch eine Unklarheit.
class Program {
static void Main(string[] args) {
Ausgabe Output = new Ausgabe();
IAusgabeArten type;
type = new Ausgabe2();
Output.TextOut(type);
Console.ReadLine();
}
}
interface IAusgabeArten {
string getText();
}
class Ausgabe {
public string TextOut(IAusgabeArten Ausgabe) {
Console.WriteLine(Ausgabe.getText());
}
}
class Ausgabe1 : IAusgabeArten {
public string getText() {
return "Text der Ausgabe 1";
}
}
class Ausgabe2 : IAusgabeArten {
public string getText() {
return "Text der Ausgabe 2";
}
}
Wie man dem Code ansehen sollte, wird anhand des Objekt-Typs welchen ich der Methode TextOut übergebe ein anderer Text ausgegeben. Da hier aber nur die Klasse hinter dem übergebenen Objekt ausschlaggebend ist welcher Text ausgegeben wird, hätte ich das gerne so, dass z.b. anhand einer Eingabe, also eines strings, eine andere Ausgabe gemacht wird.
Hat Jemand eine Idee wie man dies machen könnte ?
Ich hatte schon die Idee je nach dem was der Benutzer eingegeben hat ein anderes Objekt zu generieren. Aber da mache ich schlussendlich auch Gebrauch von Mehrfachverzweigungen und genau das möchte ich ja verhindern.
Vielen Dank im Voraus
Ich bin neu hier und habe auch das erste Mal mit ASP.NET zu tun.
Mein Problem liegt darin, dass ich zum Beispiel Gästebuch-Einträge aus einer Datenbank auslesen möchte und diese dann auf einer Seite anzeige.
Dazu habe ich einen kleinen Beispielcode geschrieben. Ich fülle das StringArray mit Texten und möchte diese anschlissend auf der Seite ausgeben. Dazu nutze ich eine foreach Schleife und ändere jedes Mal den Text des Literals. Also wird auf der Seite nicht nur 3 mal der Text geschrieben, sondern auch 3 mal das div.
Nun meine Frage: Gibt es eine bessere Möglichkeit solche Bereiche mehrmals ausgeben zu lassen, als diese ?
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<% //Ausgabe eines Arrays
foreach (string Text in TextArray) {
Literal1.Text = Text;
%>
<div>
<asp:Literal ID="Literal1" runat="server" />
</div>
<%
}
%>
</div>
</form>
</body>
</html>
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
public partial class _Default : System.Web.UI.Page
{
protected string[] TextArray = new String[4];
protected void Page_Load(object sender, EventArgs e)
{
TextArray[0] = "Test1";
TextArray[1] = "Test2";
TextArray[2] = "Test3";
}
}