<think>我们将在之前的WinForms立库管理系统基础上，集成SQL Server数据库，实现数据的持久化和实时更新。
主要需求：
1. 使用SQL Server存储每个库位的状态（包括当前数量、最大容量等）
2. 入库操作需要更新数据库
3. 出库操作需要更新数据库
4. 查询当前每个库位的层状态（已入层数、未入层数）
设计思路：
1. 创建数据库表：StorageUnits
- UnitId (int, PK)
- MaxCapacity (int, not null)
- CurrentCount (int, not null)
- 其他字段（如位置描述等，根据需求扩展）
2. 在应用程序启动时从数据库加载库位状态
3. 每次入库/出库操作后，更新内存中的对象，并同步更新数据库
4. 层数计算：我们假设每层16个（因为208/16=13层），所以在数据库中不直接存储层数，而是根据CurrentCount计算
步骤：
1. 创建数据库和表
2. 在C#项目中添加数据库连接
3. 实现数据访问层（DAL）用于加载和保存库位状态
4. 修改业务逻辑层（BLL）在操作时调用DAL方法
下面我们逐步实现：</think># 基于 SQL Server 的立库管理系统实现
下面我将实现一个完整的立库管理系统，使用 SQL Server 进行数据存储，满足您的所有需求：10个立库、每个库位满载208个、分散入库、可视化状态显示、单独设置出库数量，以及实时查询层状态。
## 数据库设计
首先创建 SQL Server 数据库和表结构：
```sql
CREATE DATABASE WarehouseManagement;
GO
USE WarehouseManagement;
GO
-- 库位表
CREATE TABLE StorageUnits (
UnitID INT PRIMARY KEY IDENTITY(1,1),
UnitName NVARCHAR(50) NOT NULL,
MaxCapacity INT NOT NULL DEFAULT 208,
CurrentCount INT NOT NULL DEFAULT 0,
LastUpdate DATETIME NOT NULL DEFAULT GETDATE()
);
-- 入库记录表
CREATE TABLE InboundRecords (
RecordID INT PRIMARY KEY IDENTITY(1,1),
UnitID INT NOT NULL,
Quantity INT NOT NULL,
OperationTime DATETIME NOT NULL DEFAULT GETDATE(),
FOREIGN KEY (UnitID) REFERENCES StorageUnits(UnitID)
);
-- 出库记录表
CREATE TABLE OutboundRecords (
RecordID INT PRIMARY KEY IDENTITY(1,1),
UnitID INT NOT NULL,
Quantity INT NOT NULL,
OperationTime DATETIME NOT NULL DEFAULT GETDATE(),
FOREIGN KEY (UnitID) REFERENCES StorageUnits(UnitID)
);
-- 初始化10个库位
INSERT INTO StorageUnits (UnitName, MaxCapacity, CurrentCount)
VALUES
('立库01', 208, 0),
('立库02', 208, 0),
('立库03', 208, 0),
('立库04', 208, 0),
('立库05', 208, 0),
('立库06', 208, 0),
('立库07', 208, 0),
('立库08', 208, 0),
('立库09', 208, 0),
('立库10', 208, 0);
```
## C# WinForms 实现
```csharp
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
namespace WarehouseManagementSystem
{
public partial class MainForm : Form
{
private const string ConnectionString = "Server=localhost;Database=WarehouseManagement;Integrated Security=True;";
private const int ItemsPerLayer = 16; // 每层物品数量
public MainForm()
{
InitializeComponent();
InitializeUI();
LoadStorageUnits();
UpdateStatistics();
}
private void InitializeUI()
{
this.Text = "立库管理系统 - SQL Server";
this.Size = new Size(1200, 800);
this.BackColor = Color.White;
// 主布局
TableLayoutPanel mainLayout = new TableLayoutPanel
{
Dock = DockStyle.Fill,
ColumnCount = 1,
RowCount = 3,
Padding = new Padding(10)
};
mainLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 70));
mainLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 15));
mainLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 15));
this.Controls.Add(mainLayout);
// 仓库单元面板
Panel unitsPanel = new Panel
{
Dock = DockStyle.Fill,
AutoScroll = true,
BorderStyle = BorderStyle.FixedSingle
};
mainLayout.Controls.Add(unitsPanel, 0, 0);
// 创建10个仓库单元面板
FlowLayoutPanel flowPanel = new FlowLayoutPanel
{
Dock = DockStyle.Fill,
FlowDirection = FlowDirection.TopDown,
AutoScroll = true,
WrapContents = false
};
unitsPanel.Controls.Add(flowPanel);
// 统计信息面板
Panel statsPanel = new Panel
{
Dock = DockStyle.Fill,
BorderStyle = BorderStyle.FixedSingle,
BackColor = Color.LightGray
};
mainLayout.Controls.Add(statsPanel, 0, 1);
// 入库面板
Panel inboundPanel = new Panel
{
Dock = DockStyle.Fill,
BorderStyle = BorderStyle.FixedSingle
};
mainLayout.Controls.Add(inboundPanel, 0, 2);
// 添加控件到各个面板
InitializeUnitsPanel(flowPanel);
InitializeStatsPanel(statsPanel);
InitializeInboundPanel(inboundPanel);
}
private void InitializeUnitsPanel(FlowLayoutPanel flowPanel)
{
for (int i = 1; i <= 10; i++)
{
UnitControl unitControl = new UnitControl(i);
unitControl.OutboundRequested += UnitControl_OutboundRequested;
flowPanel.Controls.Add(unitControl);
}
}
private void InitializeStatsPanel(Panel statsPanel)
{
TableLayoutPanel statsLayout = new TableLayoutPanel
{
Dock = DockStyle.Fill,
ColumnCount = 2,
RowCount = 3
};
statsPanel.Controls.Add(statsLayout);
// 总库存统计
Label lblTotalTitle = new Label
{
Text = "总库存统计",
Font = new Font("Microsoft Sans Serif", 12, FontStyle.Bold),
Dock = DockStyle.Fill,
TextAlign = ContentAlignment.MiddleCenter
};
statsLayout.Controls.Add(lblTotalTitle, 0, 0);
lblTotalStats = new Label
{
Text = "",
Font = new Font("Microsoft Sans Serif", 10),
Dock = DockStyle.Fill,
TextAlign = ContentAlignment.MiddleLeft
};
statsLayout.Controls.Add(lblTotalStats, 1, 0);
// 层统计
Label lblLayerTitle = new Label
{
Text = "层统计信息",
Font = new Font("Microsoft Sans Serif", 12, FontStyle.Bold),
Dock = DockStyle.Fill,
TextAlign = ContentAlignment.MiddleCenter
};
statsLayout.Controls.Add(lblLayerTitle, 0, 1);
lblLayerStats = new Label
{
Text = "",
Font = new Font("Microsoft Sans Serif", 10),
Dock = DockStyle.Fill,
TextAlign = ContentAlignment.MiddleLeft
};
statsLayout.Controls.Add(lblLayerStats, 1, 1);
// 刷新按钮
Button btnRefresh = new Button
{
Text = "刷新数据",
Dock = DockStyle.Fill,
BackColor = Color.LightBlue
};
btnRefresh.Click += (s, e) => {
LoadStorageUnits();
UpdateStatistics();
};
statsLayout.Controls.Add(btnRefresh, 0, 2);
statsLayout.SetColumnSpan(btnRefresh, 2);
}
private void InitializeInboundPanel(Panel inboundPanel)
{
TableLayoutPanel inboundLayout = new TableLayoutPanel
{
Dock = DockStyle.Fill,
ColumnCount = 4,
RowCount = 1
};
inboundPanel.Controls.Add(inboundLayout);
// 入库数量输入
Label lblInbound = new Label
{
Text = "入库数量:",
Dock = DockStyle.Fill,
TextAlign = ContentAlignment.MiddleRight
};
inboundLayout.Controls.Add(lblInbound, 0, 0);
txtInboundAmount = new NumericUpDown
{
Minimum = 1,
Maximum = 10000,
Value = 100,
Dock = DockStyle.Fill
};
inboundLayout.Controls.Add(txtInboundAmount, 1, 0);
// 入库按钮
btnInbound = new Button
{
Text = "执行入库",
Dock = DockStyle.Fill,
BackColor = Color.LightGreen
};
btnInbound.Click += BtnInbound_Click;
inboundLayout.Controls.Add(btnInbound, 2, 0);
// 出库按钮
btnOutboundAll = new Button
{
Text = "执行所有出库",
Dock = DockStyle.Fill,
BackColor = Color.LightCoral
};
btnOutboundAll.Click += BtnOutboundAll_Click;
inboundLayout.Controls.Add(btnOutboundAll, 3, 0);
}
private void LoadStorageUnits()
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
string query = "SELECT UnitID, UnitName, MaxCapacity, CurrentCount FROM StorageUnits";
using (SqlCommand cmd = new SqlCommand(query, conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
int unitId = reader.GetInt32(0);
string unitName = reader.GetString(1);
int maxCapacity = reader.GetInt32(2);
int currentCount = reader.GetInt32(3);
// 更新UI中的单元控件
foreach (Control control in GetAllUnitControls())
{
if (control is UnitControl unitControl && unitControl.UnitId == unitId)
{
unitControl.UpdateData(maxCapacity, currentCount);
break;
}
}
}
}
}
}
private void UpdateStatistics()
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
// 总库存统计
string totalQuery = "SELECT SUM(CurrentCount), SUM(MaxCapacity) FROM StorageUnits";
using (SqlCommand cmd = new SqlCommand(totalQuery, conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
int totalCurrent = reader.IsDBNull(0) ? 0 : reader.GetInt32(0);
int totalMax = reader.IsDBNull(1) ? 0 : reader.GetInt32(1);
lblTotalStats.Text = $"总库存: {totalCurrent} / {totalMax}\n空闲容量: {totalMax - totalCurrent}";
}
}
// 层统计
string layerQuery = @"
SELECT
SUM(CurrentCount) AS TotalItems,
COUNT(*) * (@itemsPerLayer) AS TotalSlots,
SUM(CurrentCount / @itemsPerLayer) AS FullLayers,
SUM(CurrentCount % @itemsPerLayer) AS PartialItems
FROM StorageUnits";
using (SqlCommand cmd = new SqlCommand(layerQuery, conn))
{
cmd.Parameters.AddWithValue("@itemsPerLayer", ItemsPerLayer);
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
int totalItems = reader.GetInt32(0);
int totalSlots = reader.GetInt32(1);
int fullLayers = reader.GetInt32(2);
int partialItems = reader.GetInt32(3);
int usedLayers = fullLayers + (partialItems > 0 ? 1 : 0);
int totalLayers = totalSlots / ItemsPerLayer;
int freeLayers = totalLayers - usedLayers;
lblLayerStats.Text = $"总层数: {totalLayers}\n已入层: {usedLayers}\n未入层: {freeLayers}\n部分填充层: {fullLayers}整层 + {partialItems}个物品";
}
}
}
}
}
private void BtnInbound_Click(object sender, EventArgs e)
{
int totalItems = (int)txtInboundAmount.Value;
try
{
// 获取当前库位状态
List<StorageUnit> units = new List<StorageUnit>();
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
string query = "SELECT UnitID, MaxCapacity, CurrentCount FROM StorageUnits";
using (SqlCommand cmd = new SqlCommand(query, conn))
using (SqlDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
units.Add(new StorageUnit
{
UnitId = reader.GetInt32(0),
MaxCapacity = reader.GetInt32(1),
CurrentCount = reader.GetInt32(2)
});
}
}
}
// 计算分配方案
var distribution = CalculateDistribution(units, totalItems);
// 执行入库操作
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
foreach (var item in distribution)
{
// 更新库位
string updateQuery = @"
UPDATE StorageUnits
SET CurrentCount = CurrentCount + @quantity,
LastUpdate = GETDATE()
WHERE UnitID = @unitId";
using (SqlCommand cmd = new SqlCommand(updateQuery, conn))
{
cmd.Parameters.AddWithValue("@quantity", item.Quantity);
cmd.Parameters.AddWithValue("@unitId", item.UnitId);
cmd.ExecuteNonQuery();
}
// 记录入库操作
string recordQuery = @"
INSERT INTO InboundRecords (UnitID, Quantity)
VALUES (@unitId, @quantity)";
using (SqlCommand cmd = new SqlCommand(recordQuery, conn))
{
cmd.Parameters.AddWithValue("@unitId", item.UnitId);
cmd.Parameters.AddWithValue("@quantity", item.Quantity);
cmd.ExecuteNonQuery();
}
}
}
MessageBox.Show($"成功入库 {totalItems} 个物品", "操作成功",
MessageBoxButtons.OK, MessageBoxIcon.Information);
// 刷新界面
LoadStorageUnits();
UpdateStatistics();
}
catch (Exception ex)
{
MessageBox.Show($"入库操作失败: {ex.Message}", "错误",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private List<DistributionItem> CalculateDistribution(List<StorageUnit> units, int totalItems)
{
List<DistributionItem> distribution = new List<DistributionItem>();
// 1. 计算平均分配量
int baseAmount = totalItems / units.Count;
int remainder = totalItems % units.Count;
// 2. 按库位空闲容量排序
var sortedUnits = units.OrderBy(u => u.CurrentCount).ToList();
// 3. 分配基础量
for (int i = 0; i < sortedUnits.Count; i++)
{
int amount = baseAmount + (i < remainder ? 1 : 0);
int actualAmount = Math.Min(amount, sortedUnits[i].MaxCapacity - sortedUnits[i].CurrentCount);
distribution.Add(new DistributionItem
{
UnitId = sortedUnits[i].UnitId,
Quantity = actualAmount
});
totalItems -= actualAmount;
}
// 4. 分配剩余物品
while (totalItems > 0)
{
bool distributed = false;
foreach (var unit in sortedUnits)
{
if (totalItems <= 0) break;
int available = unit.MaxCapacity - unit.CurrentCount -
distribution.First(d => d.UnitId == unit.UnitId).Quantity;
if (available > 0)
{
int addAmount = Math.Min(available, totalItems);
distribution.First(d => d.UnitId == unit.UnitId).Quantity += addAmount;
totalItems -= addAmount;
distributed = true;
}
}
if (!distributed) break;
}
if (totalItems > 0)
{
throw new Exception($"无法完全入库，剩余 {totalItems} 个物品（库位已满）");
}
return distribution;
}
private void UnitControl_OutboundRequested(object sender, OutboundEventArgs e)
{
try
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
conn.Open();
// 检查库存是否足够
string checkQuery = "SELECT CurrentCount FROM StorageUnits WHERE UnitID = @unitId";
int currentCount = 0;
using (SqlCommand cmd = new SqlCommand(checkQuery, conn))
{
cmd.Parameters.AddWithValue("@unitId", e.UnitId);
currentCount = (int)cmd.ExecuteScalar();
}
if (currentCount < e.Quantity)
{
throw new Exception($"库存不足，当前库存: {currentCount}");
}
// 更新库位
string updateQuery = @"
UPDATE StorageUnits
SET CurrentCount = CurrentCount - @quantity,
LastUpdate = GETDATE()
WHERE UnitID = @unitId";
using (SqlCommand cmd = new SqlCommand(updateQuery, conn))
{
cmd.Parameters.AddWithValue("@quantity", e.Quantity);
cmd.Parameters.AddWithValue("@unitId", e.UnitId);
cmd.ExecuteNonQuery();
}
// 记录出库操作
string recordQuery = @"
INSERT INTO OutboundRecords (UnitID, Quantity)
VALUES (@unitId, @quantity)";
using (SqlCommand cmd = new SqlCommand(recordQuery, conn))
{
cmd.Parameters.AddWithValue("@unitId", e.UnitId);
cmd.Parameters.AddWithValue("@quantity", e.Quantity);
cmd.ExecuteNonQuery();
}
// 刷新UI
LoadStorageUnits();
UpdateStatistics();
MessageBox.Show($"成功从库位 {e.UnitId} 出库 {e.Quantity} 个物品", "操作成功",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
catch (Exception ex)
{
MessageBox.Show($"出库操作失败: {ex.Message}", "错误",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void BtnOutboundAll_Click(object sender, EventArgs e)
{
try
{
foreach (Control control in GetAllUnitControls())
{
if (control is UnitControl unitControl && unitControl.HasOutboundRequest())
{
var args = unitControl.GetOutboundRequest();
UnitControl_OutboundRequested(unitControl, args);
}
}
}
catch (Exception ex)
{
MessageBox.Show($"批量出库操作失败: {ex.Message}", "错误",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private IEnumerable<UnitControl> GetAllUnitControls()
{
var unitsPanel = this.Controls[0].Controls[0] as Panel;
var flowPanel = unitsPanel.Controls[0] as FlowLayoutPanel;
return flowPanel.Controls.OfType<UnitControl>();
}
}
// 辅助类
public class StorageUnit
{
public int UnitId { get; set; }
public int MaxCapacity { get; set; }
public int CurrentCount { get; set; }
}
public class DistributionItem
{
public int UnitId { get; set; }
public int Quantity { get; set; }
}
// 自定义事件参数
public class OutboundEventArgs : EventArgs
{
public int UnitId { get; set; }
public int Quantity { get; set; }
}
// 库位用户控件
public class UnitControl : UserControl
{
public int UnitId { get; }
private ProgressBar progressBar;
private Label lblStatus;
private Label lblLayers;
private TextBox txtOutbound;
private Button btnOutbound;
public event EventHandler<OutboundEventArgs> OutboundRequested;
public UnitControl(int unitId)
{
UnitId = unitId;
InitializeComponents();
}
private void InitializeComponents()
{
this.Size = new Size(800, 80);
this.BorderStyle = BorderStyle.FixedSingle;
this.Margin = new Padding(5);
// 库位标签
Label lblUnit = new Label
{
Text = $"库位 {UnitId}",
Font = new Font("Microsoft Sans Serif", 10, FontStyle.Bold),
Location = new Point(10, 10),
AutoSize = true
};
this.Controls.Add(lblUnit);
// 进度条
progressBar = new ProgressBar
{
Minimum = 0,
Maximum = 208,
Value = 0,
Location = new Point(100, 15),
Size = new Size(400, 20)
};
this.Controls.Add(progressBar);
// 状态标签
lblStatus = new Label
{
Text = "0/208",
Location = new Point(510, 15),
AutoSize = true
};
this.Controls.Add(lblStatus);
// 层信息标签
lblLayers = new Label
{
Text = "层: 0/13",
Location = new Point(510, 40),
AutoSize = true
};
this.Controls.Add(lblLayers);
// 出库文本框
txtOutbound = new TextBox
{
Location = new Point(600, 15),
Size = new Size(60, 20),
Tag = UnitId
};
this.Controls.Add(txtOutbound);
// 出库按钮
btnOutbound = new Button
{
Text = "出库",
Location = new Point(670, 10),
Size = new Size(60, 30),
BackColor = Color.LightCoral,
Tag = UnitId
};
btnOutbound.Click += BtnOutbound_Click;
this.Controls.Add(btnOutbound);
}
public void UpdateData(int maxCapacity, int currentCount)
{
progressBar.Maximum = maxCapacity;
progressBar.Value = currentCount;
lblStatus.Text = $"{currentCount}/{maxCapacity}";
// 计算层信息
int totalLayers = maxCapacity / 16;
int usedLayers = (int)Math.Ceiling((double)currentCount / 16);
int freeLayers = totalLayers - usedLayers;
lblLayers.Text = $"层: {usedLayers}/{totalLayers} (空闲: {freeLayers})";
}
public bool HasOutboundRequest()
{
return !string.IsNullOrEmpty(txtOutbound.Text) &&
int.TryParse(txtOutbound.Text, out int quantity) &&
quantity > 0;
}
public OutboundEventArgs GetOutboundRequest()
{
if (int.TryParse(txtOutbound.Text, out int quantity) && quantity > 0)
{
return new OutboundEventArgs
{
UnitId = this.UnitId,
Quantity = quantity
};
}
return null;
}
private void BtnOutbound_Click(object sender, EventArgs e)
{
if (int.TryParse(txtOutbound.Text, out int quantity) && quantity > 0)
{
OutboundRequested?.Invoke(this, new OutboundEventArgs
{
UnitId = this.UnitId,
Quantity = quantity
});
txtOutbound.Text = "";
}
else
{
MessageBox.Show("请输入有效的出库数量", "错误",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
```
## 系统功能说明
### 1. 数据库集成
- **StorageUnits 表**：存储10个库位的基本信息
- **InboundRecords 表**：记录所有入库操作
- **OutboundRecords 表**：记录所有出库操作
- **实时同步**：所有操作都直接更新数据库
### 2. 分散入库算法
```csharp
private List<DistributionItem> CalculateDistribution(List<StorageUnit> units, int totalItems)
{
// 1. 计算平均分配量
int baseAmount = totalItems / units.Count;
int remainder = totalItems % units.Count;
// 2. 按库位空闲容量排序（优先分配到空闲多的库位）
var sortedUnits = units.OrderBy(u => u.CurrentCount).ToList();
// 3. 分配基础量
for (int i = 0; i < sortedUnits.Count; i++)
{
int amount = baseAmount + (i < remainder ? 1 : 0);
int actualAmount = Math.Min(amount, sortedUnits[i].MaxCapacity - sortedUnits[i].CurrentCount);
// ...
}
// 4. 分配剩余物品
while (totalItems > 0)
{
// 遍历所有库位分配剩余物品
}
}
```
### 3. 层状态查询
```sql
SELECT
SUM(CurrentCount) AS TotalItems,
COUNT(*) * 16 AS TotalSlots, -- 每层16个物品
SUM(CurrentCount / 16) AS FullLayers,
SUM(CurrentCount % 16) AS PartialItems
FROM StorageUnits
```
### 4. 实时更新机制
- **出库操作**：通过事件机制实时更新数据库
- **入库操作**：使用事务确保数据一致性
- **UI刷新**：操作后自动刷新界面显示最新状态
### 5. 可视化界面
- **库位面板**：显示进度条、当前数量、层信息
- **统计面板**：显示总库存和层统计信息
- **控制面板**：入库控制和批量出库功能
## 使用说明
1. **入库操作**：
- 在入库数量输入框中输入要入库的数量
- 点击"执行入库"按钮
- 系统会自动将物品分散到各个库位
2. **出库操作**：
- 在每个库位的出库文本框中输入出库数量
- 点击单个库位的"出库"按钮单独出库
- 或点击"执行所有出库"按钮批量出库
3. **状态查看**：
- 进度条直观显示每个库位使用情况
- 状态标签显示当前数量/最大容量
- 层信息标签显示已使用层数/总层数
- 统计面板显示全局库存和层统计
4. **数据刷新**：
- 点击"刷新数据"按钮手动更新界面
- 所有操作后自动刷新数据
## 数据库优化建议
1. 添加索引提高查询性能：
```sql
CREATE INDEX IDX_StorageUnits_CurrentCount ON StorageUnits(CurrentCount);
CREATE INDEX IDX_InboundRecords_UnitID ON InboundRecords(UnitID);
CREATE INDEX IDX_OutboundRecords_UnitID ON OutboundRecords(UnitID);
```
2. 添加存储过程处理复杂操作：
```sql
CREATE PROCEDURE sp_DistributeInbound
@TotalItems INT
AS
BEGIN
BEGIN TRY
BEGIN TRANSACTION
-- 计算分配方案
-- 更新库位
-- 记录入库
COMMIT TRANSACTION
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION
RAISERROR('入库操作失败', 16, 1)
END CATCH
END
```
##
本文探讨了.NET和SQL在decimal、datetime、String三种数据类型上的兼容性问题，强调了在获取这些数据时避免数据截断的重要性。同时指出SQL中的所有数据类型可为空，而.NET中的引用类型可为空。
扫一扫
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
