T-SQL
/*
Stored Procedure GetstudentnameInOutputVariable is modified to collect the
email address of the student with the help of the Alert Keyword
*/
CREATE PROCEDURE GetstudentnameInOutputVariable
(
@studentid INT, --Input parameter , Studentid of the student
@studentname VARCHAR (200) OUT, -- Output parameter to collect the student name
@StudentEmail VARCHAR (200)OUT -- Output Parameter to collect the student email
)
AS
BEGIN
SELECT @studentname= Firstname+' '+Lastname,
@StudentEmail=email FROM tbl_Students WHERE studentid=@studentid
END
Не знаю метода фреймворка, но вы могли бы написать быстрый помощник, который сделает это за вас.
public static void Populate<T>(this T[] arr, T value ) {
for ( int i = 0; i < arr.Length;i++ ) {
arr[i] = value;
}
}
Для больших массивов или массивов с переменным размером вам, вероятно, следует использовать:
Enumerable.Repeat(true, 1000000).ToArray();
Для небольшого массива вы можете использовать синтаксис инициализации коллекции в C # 3:
bool[] vals = new bool[]{ false, false, false, false, false, false, false };
Преимущество коллекции синтаксис инициализации заключается в том, что вам не нужно использовать одно и то же значение в каждом слоте, и вы можете использовать выражения или функции для инициализации слота. Кроме того, я думаю, вы избежите затрат на инициализацию слота массива значением по умолчанию. Так, например:
bool[] vals = new bool[]{ false, true, false, !(a ||b) && c, SomeBoolMethod() };
Создайте новый массив с тысяча истина
значения:
var items = Enumerable.Repeat<bool>(true, 1000).ToArray(); // Or ToList(), etc.
Аналогичным образом вы можете генерировать целочисленные последовательности:
var items = Enumerable.Range(0, 1000).ToArray(); // 0..999
к сожалению, я не думаю, что существует прямой путь, однако я думаю, что вы можете написать метод расширения для класса массива, чтобы сделать это
class Program
{
static void Main(string[] args)
{
int[] arr = new int[1000];
arr.Init(10);
Array.ForEach(arr, Console.WriteLine);
}
}
public static class ArrayExtensions
{
public static void Init<T>(this T[] array, T defaultVaue)
{
if (array == null)
return;
for (int i = 0; i < array.Length; i++)
{
array[i] = defaultVaue;
}
}
}
После того, как я немного погуглил и прочитал, я нашел следующее:
bool[] bPrimes = new bool[1000000];
bPrimes = Array.ConvertAll<bool, bool>(bPrimes, b=> b=true);
Что, безусловно, ближе к тому, что я ищу. Но я не уверен, что это лучше, чем перебирать исходный массив в цикле for и просто изменять значения. Фактически, после быстрого теста он кажется медленнее примерно в 5 раз. Так что тогда не совсем хорошее решение!
это тоже работает ... но может быть ненужным
bool[] abValues = new bool[1000];
abValues = abValues.Select( n => n = true ).ToArray<bool>();
Если вы планируете установить только несколько значений в массиве, но хотите получать (пользовательское) значение по умолчанию большую часть времени, вы можете попробовать что-то вроде этого:
public class SparseArray<T>
{
private Dictionary<int, T> values = new Dictionary<int, T>();
private T defaultValue;
public SparseArray(T defaultValue)
{
this.defaultValue = defaultValue;
}
public T this [int index]
{
set { values[index] = value; }
get { return values.ContainsKey(index) ? values[index] ? defaultValue; }
}
}
Вам, вероятно, потребуется реализовать другие интерфейсы, чтобы сделать это полезным, например, интерфейсы самого массива.
Если ваш массив такой большой, вы должны использовать BitArray. Он использует 1 бит для каждого bool вместо байта (как в массиве bool), также вы можете установить для всех битов значение true с помощью битовых операторов. Или просто инициализируйте значение true. Если вам нужно сделать это только один раз, это будет стоить дороже.
System.Collections.BitArray falses = new System.Collections.BitArray(100000, false);
System.Collections.BitArray trues = new System.Collections.BitArray(100000, true);
// Now both contain only true values.
falses.And(trues);
Как насчет параллельной реализации
public static void InitializeArray<T>(T[] array, T value)
{
var cores = Environment.ProcessorCount;
ArraySegment<T>[] segments = new ArraySegment<T>[cores];
var step = array.Length / cores;
for (int i = 0; i < cores; i++)
{
segments[i] = new ArraySegment<T>(array, i * step, step);
}
var remaining = array.Length % cores;
if (remaining != 0)
{
var lastIndex = segments.Length - 1;
segments[lastIndex] = new ArraySegment<T>(array, lastIndex * step, array.Length - (lastIndex * step));
}
var initializers = new Task[cores];
for (int i = 0; i < cores; i++)
{
var index = i;
var t = new Task(() =>
{
var s = segments[index];
for (int j = 0; j < s.Count; j++)
{
array[j + s.Offset] = value;
}
});
initializers[i] = t;
t.Start();
}
Task.WaitAll(initializers);
}
При инициализации только массива сила этого кода не видна, но я думаю, что вы определенно должны забыть о "чистом" for.